Bridge++  Ver. 2.0.2
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  u0 = svld1(pg, &u[VLEN * 0]);
32  u1 = svld1(pg, &u[VLEN * 1]);
33  u2 = svld1(pg, &u[VLEN * (0 + NVC)]);
34  u3 = svld1(pg, &u[VLEN * (1 + NVC)]);
35  u4 = svld1(pg, &u[VLEN * (0 + 2 * NVC)]);
36  u5 = svld1(pg, &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  u0 = svld1(pg, &u[VLEN * 0]);
47  u1 = svld1(pg, &u[VLEN * 1]);
48  u2 = svld1(pg, &u[VLEN * 2]);
49  u3 = svld1(pg, &u[VLEN * 3]);
50  u4 = svld1(pg, &u[VLEN * 4]);
51  u5 = svld1(pg, &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  inline void mult_uv(svbool_t pg,
71  svreal_t& yr, svreal_t& yi,
72  svreal_t u0, svreal_t u1,
73  svreal_t u2, svreal_t u3,
74  svreal_t u4, svreal_t u5,
75  svreal_t v0, svreal_t v1,
76  svreal_t v2, svreal_t v3,
77  svreal_t v4, svreal_t v5)
78  {
79  yr = svmul_m(pg, u0, v0);
80  yr = svmls_m(pg, yr, u1, v1);
81  yr = svmla_m(pg, yr, u2, v2);
82  yr = svmls_m(pg, yr, u3, v3);
83  yr = svmla_m(pg, yr, u4, v4);
84  yr = svmls_m(pg, yr, u5, v5);
85  yi = svmul_m(pg, u0, v1);
86  yi = svmla_m(pg, yi, u1, v0);
87  yi = svmla_m(pg, yi, u2, v3);
88  yi = svmla_m(pg, yi, u3, v2);
89  yi = svmla_m(pg, yi, u4, v5);
90  yi = svmla_m(pg, yi, u5, v4);
91  }
92 
93 
94  inline void mult_udv(svbool_t pg,
95  svreal_t& yr, svreal_t& yi,
96  svreal_t u0, svreal_t u1,
97  svreal_t u2, svreal_t u3,
98  svreal_t u4, svreal_t u5,
99  svreal_t v0, svreal_t v1,
100  svreal_t v2, svreal_t v3,
101  svreal_t v4, svreal_t v5)
102  {
103  yr = svmul_m(pg, u0, v0);
104  yr = svmla_m(pg, yr, u1, v1);
105  yr = svmla_m(pg, yr, u2, v2);
106  yr = svmla_m(pg, yr, u3, v3);
107  yr = svmla_m(pg, yr, u4, v4);
108  yr = svmla_m(pg, yr, u5, v5);
109  yi = svmul_m(pg, u0, v1);
110  yi = svmls_m(pg, yi, u1, v0);
111  yi = svmla_m(pg, yi, u2, v3);
112  yi = svmls_m(pg, yi, u3, v2);
113  yi = svmla_m(pg, yi, u4, v5);
114  yi = svmls_m(pg, yi, u5, v4);
115  }
116 
117 
118  inline void mult_ctv(Vsimd_t *x, Vsimd_t *u, Vsimd_t *w, int Nc)
119  {
120  for (int k = 0; k < VLEN; ++k) {
121  x[0].v[k] =
122  u[0].v[k] * w[0].v[k] - u[1].v[k] * w[1].v[k]
123  + u[6].v[k] * w[2 * ND].v[k] - u[7].v[k] * w[2 * ND + 1].v[k]
124  + u[12].v[k] * w[4 * ND].v[k] - u[13].v[k] * w[4 * ND + 1].v[k];
125  x[1].v[k] =
126  u[0].v[k] * w[1].v[k] + u[1].v[k] * w[0].v[k]
127  + u[6].v[k] * w[2 * ND + 1].v[k] + u[7].v[k] * w[2 * ND].v[k]
128  + u[12].v[k] * w[4 * ND + 1].v[k] + u[13].v[k] * w[4 * ND].v[k];
129  }
130  }
131 
132 
133  inline void mult_uv(Vsimd_t *x, Vsimd_t *u, Vsimd_t *w, int Nc)
134  {
135  for (int k = 0; k < VLEN; ++k) {
136  x[0].v[k] =
137  u[0].v[k] * w[0].v[k] - u[1].v[k] * w[1].v[k]
138  + u[6].v[k] * w[2].v[k] - u[7].v[k] * w[3].v[k]
139  + u[12].v[k] * w[4].v[k] - u[13].v[k] * w[5].v[k];
140  x[1].v[k] =
141  u[0].v[k] * w[1].v[k] + u[1].v[k] * w[0].v[k]
142  + u[6].v[k] * w[3].v[k] + u[7].v[k] * w[2].v[k]
143  + u[12].v[k] * w[5].v[k] + u[13].v[k] * w[4].v[k];
144  }
145  }
146 
147 
148  inline void mult_udagv(Vsimd_t *x, Vsimd_t *u, Vsimd_t *w, int Nc)
149  {
150  for (int k = 0; k < VLEN; ++k) {
151  x[0].v[k] =
152  u[0].v[k] * w[0].v[k] + u[1].v[k] * w[1].v[k]
153  + u[2].v[k] * w[2].v[k] + u[3].v[k] * w[3].v[k]
154  + u[4].v[k] * w[4].v[k] + u[5].v[k] * w[5].v[k];
155  x[1].v[k] =
156  u[0].v[k] * w[1].v[k] - u[1].v[k] * w[0].v[k]
157  + u[2].v[k] * w[3].v[k] - u[3].v[k] * w[2].v[k]
158  + u[4].v[k] * w[5].v[k] - u[5].v[k] * w[4].v[k];
159  }
160  }
161 
162 
163  template<typename REALTYPE>
164  inline void load_sp4(svbool_t pg,
165  svreal_t& vt1r, svreal_t& vt1i,
166  svreal_t& vt2r, svreal_t& vt2i,
167  svreal_t& vt3r, svreal_t& vt3i,
168  svreal_t& vt4r, svreal_t& vt4i,
169  REALTYPE *v, int ic)
170  {
171  int ic2 = ND * 2 * ic;
172  load_vec(pg, vt1r, &v[VLEN * (ic2 + ID1)]);
173  load_vec(pg, vt1i, &v[VLEN * (ic2 + 1 + ID1)]);
174  load_vec(pg, vt2r, &v[VLEN * (ic2 + ID2)]);
175  load_vec(pg, vt2i, &v[VLEN * (ic2 + 1 + ID2)]);
176  load_vec(pg, vt3r, &v[VLEN * (ic2 + ID3)]);
177  load_vec(pg, vt3i, &v[VLEN * (ic2 + 1 + ID3)]);
178  load_vec(pg, vt4r, &v[VLEN * (ic2 + ID4)]);
179  load_vec(pg, vt4i, &v[VLEN * (ic2 + 1 + ID4)]);
180  }
181 
182 
183  template<typename REALTYPE>
184  inline void set_sp4(svbool_t pg, REALTYPE *v,
185  svreal_t vt1r, svreal_t vt1i,
186  svreal_t vt2r, svreal_t vt2i,
187  svreal_t vt3r, svreal_t vt3i,
188  svreal_t vt4r, svreal_t vt4i,
189  int ic)
190  {
191  int ic2 = ND * 2 * ic;
192  svst1(pg, &v[VLEN * (ic2 + ID1)], vt1r);
193  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vt1i);
194  svst1(pg, &v[VLEN * (ic2 + ID2)], vt2r);
195  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vt2i);
196  svst1(pg, &v[VLEN * (ic2 + ID3)], vt3r);
197  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vt3i);
198  svst1(pg, &v[VLEN * (ic2 + ID4)], vt4r);
199  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vt4i);
200  }
201 
202 
203  template<typename REALTYPE>
204  inline void set_sp2_xp(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
205  {
206  for (int ic = 0; ic < NC; ++ic) {
207  int icr = ND * 2 * ic;
208  int ici = ND * 2 * ic + 1;
209  for (int k = 0; k < VLEN; ++k) {
210  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (ici + ID4)];
211  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (icr + ID4)];
212  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (ici + ID3)];
213  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (icr + ID3)];
214  }
215  }
216  }
217 
218 
219  inline void set_sp2_xp(svbool_t pg,
220  svreal_t& vt1r, svreal_t& vt1i,
221  svreal_t& vt2r, svreal_t& vt2i,
222  real_t *v, int ic)
223  {
224  int icr = ND * 2 * ic;
225  int ici = ND * 2 * ic + 1;
226  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
227  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
228  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
229  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
230  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
231  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
232  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
233  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
234  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
235 
236  vt1r = svadd_m(pg, w1r, w4i);
237  vt1i = svsub_m(pg, w1i, w4r);
238  vt2r = svadd_m(pg, w2r, w3i);
239  vt2i = svsub_m(pg, w2i, w3r);
240  }
241 
242 
243  inline void set_sp2_xp(svbool_t pg,
244  svreal_t& vt1r, svreal_t& vt1i,
245  svreal_t& vt2r, svreal_t& vt2i,
246  real_t *v, int ic, svint_t index)
247  {
248  int icr = ND * 2 * ic;
249  int ici = ND * 2 * ic + 1;
250  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
251  load_vec_gather(pg, w1r, &v[VLEN * (icr + ID1)], index);
252  load_vec_gather(pg, w1i, &v[VLEN * (ici + ID1)], index);
253  load_vec_gather(pg, w2r, &v[VLEN * (icr + ID2)], index);
254  load_vec_gather(pg, w2i, &v[VLEN * (ici + ID2)], index);
255  load_vec_gather(pg, w3r, &v[VLEN * (icr + ID3)], index);
256  load_vec_gather(pg, w3i, &v[VLEN * (ici + ID3)], index);
257  load_vec_gather(pg, w4r, &v[VLEN * (icr + ID4)], index);
258  load_vec_gather(pg, w4i, &v[VLEN * (ici + ID4)], index);
259 
260  vt1r = svadd_m(pg, w1r, w4i);
261  vt1i = svsub_m(pg, w1i, w4r);
262  vt2r = svadd_m(pg, w2r, w3i);
263  vt2i = svsub_m(pg, w2i, w3r);
264  }
265 
266 
267  template<typename REALTYPE>
268  inline void set_sp2_xp1(REALTYPE *vt, REALTYPE *w)
269  {
270  for (int ic = 0; ic < NC; ++ic) {
271  int icr = ND * 2 * ic;
272  int ici = ND * 2 * ic + 1;
273  for (int ky = 0; ky < VLENY; ++ky) {
274  vt[ky + VLENY * (2 * ic)] = w[ky + VLENY * (icr + ID1)]
275  + w[ky + VLENY * (ici + ID4)];
276  vt[ky + VLENY * (2 * ic + 1)] = w[ky + VLENY * (ici + ID1)]
277  - w[ky + VLENY * (icr + ID4)];
278  vt[ky + VLENY * (2 * ic + NVC)] = w[ky + VLENY * (icr + ID2)]
279  + w[ky + VLENY * (ici + ID3)];
280  vt[ky + VLENY * (2 * ic + 1 + NVC)] = w[ky + VLENY * (ici + ID2)]
281  - w[ky + VLENY * (icr + ID3)];
282  }
283  }
284  }
285 
286 
287  template<typename REALTYPE>
288  inline void set_sp2_xm(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
289  {
290  for (int ic = 0; ic < NC; ++ic) {
291  int icr = ND * 2 * ic;
292  int ici = ND * 2 * ic + 1;
293  for (int k = 0; k < VLEN; ++k) {
294  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (ici + ID4)];
295  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (icr + ID4)];
296  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (ici + ID3)];
297  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (icr + ID3)];
298  }
299  }
300  }
301 
302 
303  inline void set_sp2_xm(svbool_t pg,
304  svreal_t& vt1r, svreal_t& vt1i,
305  svreal_t& vt2r, svreal_t& vt2i,
306  real_t *v, int ic)
307  {
308  int icr = ND * 2 * ic;
309  int ici = ND * 2 * ic + 1;
310  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
311  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
312  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
313  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
314  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
315  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
316  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
317  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
318  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
319 
320  vt1r = svsub_m(pg, w1r, w4i);
321  vt1i = svadd_m(pg, w1i, w4r);
322  vt2r = svsub_m(pg, w2r, w3i);
323  vt2i = svadd_m(pg, w2i, w3r);
324  }
325 
326 
327  inline void set_sp2_xm(svbool_t pg,
328  svreal_t& vt1r, svreal_t& vt1i,
329  svreal_t& vt2r, svreal_t& vt2i,
330  real_t *v, int ic, svint_t index)
331  {
332  int icr = ND * 2 * ic;
333  int ici = ND * 2 * ic + 1;
334  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
335  load_vec_gather(pg, w1r, &v[VLEN * (icr + ID1)], index);
336  load_vec_gather(pg, w1i, &v[VLEN * (ici + ID1)], index);
337  load_vec_gather(pg, w2r, &v[VLEN * (icr + ID2)], index);
338  load_vec_gather(pg, w2i, &v[VLEN * (ici + ID2)], index);
339  load_vec_gather(pg, w3r, &v[VLEN * (icr + ID3)], index);
340  load_vec_gather(pg, w3i, &v[VLEN * (ici + ID3)], index);
341  load_vec_gather(pg, w4r, &v[VLEN * (icr + ID4)], index);
342  load_vec_gather(pg, w4i, &v[VLEN * (ici + ID4)], index);
343 
344  vt1r = svsub_m(pg, w1r, w4i);
345  vt1i = svadd_m(pg, w1i, w4r);
346  vt2r = svsub_m(pg, w2r, w3i);
347  vt2i = svadd_m(pg, w2i, w3r);
348  }
349 
350 
351  template<typename REALTYPE>
352  inline void set_sp2_yp(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
353  {
354  for (int ic = 0; ic < NC; ++ic) {
355  int icr = ND * 2 * ic;
356  int ici = ND * 2 * ic + 1;
357  for (int k = 0; k < VLEN; ++k) {
358  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (icr + ID4)];
359  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (ici + ID4)];
360  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (icr + ID3)];
361  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (ici + ID3)];
362  }
363  }
364  }
365 
366 
367  inline void set_sp2_yp(svbool_t pg,
368  svreal_t& vt1r, svreal_t& vt1i,
369  svreal_t& vt2r, svreal_t& vt2i,
370  real_t *v, int ic)
371  {
372  int icr = ND * 2 * ic;
373  int ici = ND * 2 * ic + 1;
374  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
375  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
376  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
377  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
378  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
379  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
380  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
381  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
382  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
383 
384  vt1r = svsub_m(pg, w1r, w4r);
385  vt1i = svsub_m(pg, w1i, w4i);
386  vt2r = svadd_m(pg, w2r, w3r);
387  vt2i = svadd_m(pg, w2i, w3i);
388  }
389 
390 
391  inline void set_sp2_yp(svbool_t pg,
392  svreal_t& vt1r, svreal_t& vt1i,
393  svreal_t& vt2r, svreal_t& vt2i,
394  real_t *v, int ic, svint_t index)
395  {
396  int icr = ND * 2 * ic;
397  int ici = ND * 2 * ic + 1;
398  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
399  load_vec_gather(pg, w1r, &v[VLEN * (icr + ID1)], index);
400  load_vec_gather(pg, w1i, &v[VLEN * (ici + ID1)], index);
401  load_vec_gather(pg, w2r, &v[VLEN * (icr + ID2)], index);
402  load_vec_gather(pg, w2i, &v[VLEN * (ici + ID2)], index);
403  load_vec_gather(pg, w3r, &v[VLEN * (icr + ID3)], index);
404  load_vec_gather(pg, w3i, &v[VLEN * (ici + ID3)], index);
405  load_vec_gather(pg, w4r, &v[VLEN * (icr + ID4)], index);
406  load_vec_gather(pg, w4i, &v[VLEN * (ici + ID4)], index);
407 
408  vt1r = svsub_m(pg, w1r, w4r);
409  vt1i = svsub_m(pg, w1i, w4i);
410  vt2r = svadd_m(pg, w2r, w3r);
411  vt2i = svadd_m(pg, w2i, w3i);
412  }
413 
414 
415  template<typename REALTYPE>
416  inline void set_sp2_yp1(REALTYPE *vt, REALTYPE *w)
417  {
418  for (int ic = 0; ic < NC; ++ic) {
419  int icr = ND * 2 * ic;
420  int ici = ND * 2 * ic + 1;
421  for (int kx = 0; kx < VLENX; ++kx) {
422  vt[kx + VLENX * (2 * ic)] = w[kx + VLENX * (icr + ID1)]
423  - w[kx + VLENX * (icr + ID4)];
424  vt[kx + VLENX * (2 * ic + 1)] = w[kx + VLENX * (ici + ID1)]
425  - w[kx + VLENX * (ici + ID4)];
426  vt[kx + VLENX * (2 * ic + NVC)] = w[kx + VLENX * (icr + ID2)]
427  + w[kx + VLENX * (icr + ID3)];
428  vt[kx + VLENX * (2 * ic + 1 + NVC)] = w[kx + VLENX * (ici + ID2)]
429  + w[kx + VLENX * (ici + ID3)];
430  }
431  }
432  }
433 
434 
435  template<typename REALTYPE>
436  inline void set_sp2_ym(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
437  {
438  for (int ic = 0; ic < NC; ++ic) {
439  int icr = ND * 2 * ic;
440  int ici = ND * 2 * ic + 1;
441  for (int k = 0; k < VLEN; ++k) {
442  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (icr + ID4)];
443  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (ici + ID4)];
444  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (icr + ID3)];
445  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (ici + ID3)];
446  }
447  }
448  }
449 
450 
451  inline void set_sp2_ym(svbool_t pg,
452  svreal_t& vt1r, svreal_t& vt1i,
453  svreal_t& vt2r, svreal_t& vt2i,
454  real_t *v, int ic)
455  {
456  int icr = ND * 2 * ic;
457  int ici = ND * 2 * ic + 1;
458  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
459  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
460  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
461  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
462  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
463  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
464  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
465  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
466  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
467 
468  vt1r = svadd_m(pg, w1r, w4r);
469  vt1i = svadd_m(pg, w1i, w4i);
470  vt2r = svsub_m(pg, w2r, w3r);
471  vt2i = svsub_m(pg, w2i, w3i);
472  }
473 
474 
475  inline void set_sp2_ym(svbool_t pg,
476  svreal_t& vt1r, svreal_t& vt1i,
477  svreal_t& vt2r, svreal_t& vt2i,
478  real_t *v, int ic, svint_t index)
479  {
480  int icr = ND * 2 * ic;
481  int ici = ND * 2 * ic + 1;
482  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
483  load_vec_gather(pg, w1r, &v[VLEN * (icr + ID1)], index);
484  load_vec_gather(pg, w1i, &v[VLEN * (ici + ID1)], index);
485  load_vec_gather(pg, w2r, &v[VLEN * (icr + ID2)], index);
486  load_vec_gather(pg, w2i, &v[VLEN * (ici + ID2)], index);
487  load_vec_gather(pg, w3r, &v[VLEN * (icr + ID3)], index);
488  load_vec_gather(pg, w3i, &v[VLEN * (ici + ID3)], index);
489  load_vec_gather(pg, w4r, &v[VLEN * (icr + ID4)], index);
490  load_vec_gather(pg, w4i, &v[VLEN * (ici + ID4)], index);
491 
492  vt1r = svadd_m(pg, w1r, w4r);
493  vt1i = svadd_m(pg, w1i, w4i);
494  vt2r = svsub_m(pg, w2r, w3r);
495  vt2i = svsub_m(pg, w2i, w3i);
496  }
497 
498 
499  template<typename REALTYPE>
500  inline void set_sp2_zp(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
501  {
502  for (int ic = 0; ic < NC; ++ic) {
503  int icr = ND * 2 * ic;
504  int ici = ND * 2 * ic + 1;
505  for (int k = 0; k < VLEN; ++k) {
506  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (ici + ID3)];
507  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (icr + ID3)];
508  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (ici + ID4)];
509  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (icr + ID4)];
510  }
511  }
512  }
513 
514 
515  inline void set_sp2_zp(svbool_t pg,
516  svreal_t& vt1r, svreal_t& vt1i,
517  svreal_t& vt2r, svreal_t& vt2i,
518  real_t *v, int ic)
519  {
520  int icr = ND * 2 * ic;
521  int ici = ND * 2 * ic + 1;
522  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
523  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
524  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
525  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
526  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
527  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
528  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
529  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
530  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
531 
532  vt1r = svadd_m(pg, w1r, w3i);
533  vt1i = svsub_m(pg, w1i, w3r);
534  vt2r = svsub_m(pg, w2r, w4i);
535  vt2i = svadd_m(pg, w2i, w4r);
536  }
537 
538 
539  template<typename REALTYPE>
540  inline void set_sp2_zm(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
541  {
542  for (int ic = 0; ic < NC; ++ic) {
543  int icr = ND * 2 * ic;
544  int ici = ND * 2 * ic + 1;
545  for (int k = 0; k < VLEN; ++k) {
546  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (ici + ID3)];
547  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (icr + ID3)];
548  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (ici + ID4)];
549  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (icr + ID4)];
550  }
551  }
552  }
553 
554 
555  inline void set_sp2_zm(svbool_t pg,
556  svreal_t& vt1r, svreal_t& vt1i,
557  svreal_t& vt2r, svreal_t& vt2i,
558  real_t *v, int ic)
559  {
560  int icr = ND * 2 * ic;
561  int ici = ND * 2 * ic + 1;
562  svreal_t w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
563  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
564  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
565  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
566  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
567  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
568  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
569  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
570  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
571 
572  vt1r = svsub_m(pg, w1r, w3i);
573  vt1i = svadd_m(pg, w1i, w3r);
574  vt2r = svadd_m(pg, w2r, w4i);
575  vt2i = svsub_m(pg, w2i, w4r);
576  }
577 
578 
579  template<typename REALTYPE>
580  inline void set_sp2_tp_dirac(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
581  {
582  for (int ic = 0; ic < NC; ++ic) {
583  int icr = ND * 2 * ic;
584  int ici = ND * 2 * ic + 1;
585  for (int k = 0; k < VLEN; ++k) {
586  vt1[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID3)];
587  vt1[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID3)];
588  vt2[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID4)];
589  vt2[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID4)];
590  }
591  }
592  }
593 
594 
595  inline void set_sp2_tp_dirac(svbool_t pg,
596  svreal_t& vt1r, svreal_t& vt1i,
597  svreal_t& vt2r, svreal_t& vt2i,
598  real_t *v, int ic)
599  {
600  int icr = ND * 2 * ic;
601  int ici = ND * 2 * ic + 1;
602  svreal_t w3r, w3i, w4r, w4i;
603  load_vec(pg, w3r, &v[VLEN * (icr + ID3)]);
604  load_vec(pg, w3i, &v[VLEN * (ici + ID3)]);
605  load_vec(pg, w4r, &v[VLEN * (icr + ID4)]);
606  load_vec(pg, w4i, &v[VLEN * (ici + ID4)]);
607 
608  vt1r = svmul_m(pg, w3r, real_t(2.0));
609  vt1i = svmul_m(pg, w3i, real_t(2.0));
610  vt2r = svmul_m(pg, w4r, real_t(2.0));
611  vt2i = svmul_m(pg, w4i, real_t(2.0));
612  }
613 
614 
615  template<typename REALTYPE>
616  inline void set_sp2_tm_dirac(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
617  {
618  for (int ic = 0; ic < NC; ++ic) {
619  int icr = ND * 2 * ic;
620  int ici = ND * 2 * ic + 1;
621  for (int k = 0; k < VLEN; ++k) {
622  vt1[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID1)];
623  vt1[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID1)];
624  vt2[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID2)];
625  vt2[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID2)];
626  }
627  }
628  }
629 
630 
631  inline void set_sp2_tm_dirac(svbool_t pg,
632  svreal_t& vt1r, svreal_t& vt1i,
633  svreal_t& vt2r, svreal_t& vt2i,
634  real_t *v, int ic)
635  {
636  int icr = ND * 2 * ic;
637  int ici = ND * 2 * ic + 1;
638  svreal_t w1r, w1i, w2r, w2i;
639  load_vec(pg, w1r, &v[VLEN * (icr + ID1)]);
640  load_vec(pg, w1i, &v[VLEN * (ici + ID1)]);
641  load_vec(pg, w2r, &v[VLEN * (icr + ID2)]);
642  load_vec(pg, w2i, &v[VLEN * (ici + ID2)]);
643 
644  vt1r = svmul_m(pg, w1r, real_t(2.0));
645  vt1i = svmul_m(pg, w1i, real_t(2.0));
646  vt2r = svmul_m(pg, w2r, real_t(2.0));
647  vt2i = svmul_m(pg, w2i, real_t(2.0));
648  }
649 
650 
651  inline void set_sp4_xp(Vsimd_t *x, Vsimd_t *wt1, Vsimd_t *wt2)
652  {
653  for (int k = 0; k < VLEN; ++k) {
654  x[ID1].v[k] += wt1[0].v[k];
655  x[1 + ID1].v[k] += wt1[1].v[k];
656  x[ID2].v[k] += wt2[0].v[k];
657  x[1 + ID2].v[k] += wt2[1].v[k];
658  x[ID3].v[k] += -wt2[1].v[k];
659  x[1 + ID3].v[k] += wt2[0].v[k];
660  x[ID4].v[k] += -wt1[1].v[k];
661  x[1 + ID4].v[k] += wt1[0].v[k];
662  }
663  }
664 
665 
666  inline void set_sp4_xp(svbool_t pg, Vsimd_t *v,
667  svreal_t wt1r, svreal_t wt1i,
668  svreal_t wt2r, svreal_t wt2i, int ic)
669  {
670  int ic2 = ND * 2 * ic;
671  svreal_t vtr, vti;
672  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
673  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
674  vtr = svadd_m(pg, vtr, wt1r);
675  vti = svadd_m(pg, vti, wt1i);
676  svst1(pg, &v[ic2 + ID1].v[0], vtr);
677  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
678 
679  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
680  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
681  vtr = svadd_m(pg, vtr, wt2r);
682  vti = svadd_m(pg, vti, wt2i);
683  svst1(pg, &v[ic2 + ID2].v[0], vtr);
684  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
685 
686  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
687  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
688  vtr = svsub_m(pg, vtr, wt2i);
689  vti = svadd_m(pg, vti, wt2r);
690  svst1(pg, &v[ic2 + ID3].v[0], vtr);
691  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
692 
693  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
694  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
695  vtr = svsub_m(pg, vtr, wt1i);
696  vti = svadd_m(pg, vti, wt1r);
697  svst1(pg, &v[ic2 + ID4].v[0], vtr);
698  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
699  }
700 
701 
702  inline void set_sp4_xp(svbool_t pg, real_t *v,
703  svreal_t wt1r, svreal_t wt1i,
704  svreal_t wt2r, svreal_t wt2i, int ic)
705  {
706  int ic2 = ND * 2 * ic;
707  svreal_t vtr, vti;
708  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
709  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
710  vtr = svadd_m(pg, vtr, wt1r);
711  vti = svadd_m(pg, vti, wt1i);
712  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
713  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
714 
715  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
716  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
717  vtr = svadd_m(pg, vtr, wt2r);
718  vti = svadd_m(pg, vti, wt2i);
719  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
720  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
721 
722  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
723  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
724  vtr = svsub_m(pg, vtr, wt2i);
725  vti = svadd_m(pg, vti, wt2r);
726  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
727  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
728 
729  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
730  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
731  vtr = svsub_m(pg, vtr, wt1i);
732  vti = svadd_m(pg, vti, wt1r);
733  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
734  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
735  }
736 
737 
738  inline void set_sp4_xm(Vsimd_t *x, Vsimd_t *wt1, Vsimd_t *wt2)
739  {
740  for (int k = 0; k < VLEN; ++k) {
741  x[ID1].v[k] += wt1[0].v[k];
742  x[1 + ID1].v[k] += wt1[1].v[k];
743  x[ID2].v[k] += wt2[0].v[k];
744  x[1 + ID2].v[k] += wt2[1].v[k];
745  x[ID3].v[k] += wt2[1].v[k];
746  x[1 + ID3].v[k] += -wt2[0].v[k];
747  x[ID4].v[k] += wt1[1].v[k];
748  x[1 + ID4].v[k] += -wt1[0].v[k];
749  }
750  }
751 
752 
753  inline void set_sp4_xm(svbool_t pg, Vsimd_t *v,
754  svreal_t wt1r, svreal_t wt1i,
755  svreal_t wt2r, svreal_t wt2i, int ic)
756  {
757  int ic2 = ND * 2 * ic;
758  svreal_t vtr, vti;
759  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
760  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
761  vtr = svadd_m(pg, vtr, wt1r);
762  vti = svadd_m(pg, vti, wt1i);
763  svst1(pg, &v[ic2 + ID1].v[0], vtr);
764  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
765 
766  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
767  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
768  vtr = svadd_m(pg, vtr, wt2r);
769  vti = svadd_m(pg, vti, wt2i);
770  svst1(pg, &v[ic2 + ID2].v[0], vtr);
771  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
772 
773  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
774  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
775  vtr = svadd_m(pg, vtr, wt2i);
776  vti = svsub_m(pg, vti, wt2r);
777  svst1(pg, &v[ic2 + ID3].v[0], vtr);
778  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
779 
780  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
781  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
782  vtr = svadd_m(pg, vtr, wt1i);
783  vti = svsub_m(pg, vti, wt1r);
784  svst1(pg, &v[ic2 + ID4].v[0], vtr);
785  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
786  }
787 
788 
789  inline void set_sp4_xm(svbool_t pg, real_t *v,
790  svreal_t wt1r, svreal_t wt1i,
791  svreal_t wt2r, svreal_t wt2i, int ic)
792  {
793  int ic2 = ND * 2 * ic;
794  svreal_t vtr, vti;
795  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
796  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
797  vtr = svadd_m(pg, vtr, wt1r);
798  vti = svadd_m(pg, vti, wt1i);
799  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
800  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
801 
802  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
803  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
804  vtr = svadd_m(pg, vtr, wt2r);
805  vti = svadd_m(pg, vti, wt2i);
806  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
807  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
808 
809  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
810  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
811  vtr = svadd_m(pg, vtr, wt2i);
812  vti = svsub_m(pg, vti, wt2r);
813  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
814  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
815 
816  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
817  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
818  vtr = svadd_m(pg, vtr, wt1i);
819  vti = svsub_m(pg, vti, wt1r);
820  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
821  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
822  }
823 
824 
825  inline void set_sp4_yp(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
826  {
827  for (int k = 0; k < VLEN; ++k) {
828  v[ID1].v[k] += wt1[0].v[k];
829  v[1 + ID1].v[k] += wt1[1].v[k];
830  v[ID2].v[k] += wt2[0].v[k];
831  v[1 + ID2].v[k] += wt2[1].v[k];
832  v[ID3].v[k] += wt2[0].v[k];
833  v[1 + ID3].v[k] += wt2[1].v[k];
834  v[ID4].v[k] += -wt1[0].v[k];
835  v[1 + ID4].v[k] += -wt1[1].v[k];
836  }
837  }
838 
839 
840  inline void set_sp4_yp(svbool_t pg, Vsimd_t *v,
841  svreal_t wt1r, svreal_t wt1i,
842  svreal_t wt2r, svreal_t wt2i, int ic)
843  {
844  int ic2 = ND * 2 * ic;
845  svreal_t vtr, vti;
846  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
847  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
848  vtr = svadd_m(pg, vtr, wt1r);
849  vti = svadd_m(pg, vti, wt1i);
850  svst1(pg, &v[ic2 + ID1].v[0], vtr);
851  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
852 
853  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
854  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
855  vtr = svadd_m(pg, vtr, wt2r);
856  vti = svadd_m(pg, vti, wt2i);
857  svst1(pg, &v[ic2 + ID2].v[0], vtr);
858  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
859 
860  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
861  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
862  vtr = svadd_m(pg, vtr, wt2r);
863  vti = svadd_m(pg, vti, wt2i);
864  svst1(pg, &v[ic2 + ID3].v[0], vtr);
865  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
866 
867  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
868  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
869  vtr = svsub_m(pg, vtr, wt1r);
870  vti = svsub_m(pg, vti, wt1i);
871  svst1(pg, &v[ic2 + ID4].v[0], vtr);
872  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
873  }
874 
875 
876  inline void set_sp4_yp(svbool_t pg, real_t *v,
877  svreal_t wt1r, svreal_t wt1i,
878  svreal_t wt2r, svreal_t wt2i, int ic)
879  {
880  int ic2 = ND * 2 * ic;
881  svreal_t vtr, vti;
882 
883  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
884  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
885  vtr = svadd_m(pg, vtr, wt1r);
886  vti = svadd_m(pg, vti, wt1i);
887  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
888  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
889 
890  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
891  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
892  vtr = svadd_m(pg, vtr, wt2r);
893  vti = svadd_m(pg, vti, wt2i);
894  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
895  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
896 
897  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
898  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
899  vtr = svadd_m(pg, vtr, wt2r);
900  vti = svadd_m(pg, vti, wt2i);
901  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
902  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
903 
904  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
905  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
906  vtr = svsub_m(pg, vtr, wt1r);
907  vti = svsub_m(pg, vti, wt1i);
908  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
909  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
910  }
911 
912 
913  inline void set_sp4_ym(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
914  {
915  for (int k = 0; k < VLEN; ++k) {
916  v[ID1].v[k] += wt1[0].v[k];
917  v[1 + ID1].v[k] += wt1[1].v[k];
918  v[ID2].v[k] += wt2[0].v[k];
919  v[1 + ID2].v[k] += wt2[1].v[k];
920  v[ID3].v[k] += -wt2[0].v[k];
921  v[1 + ID3].v[k] += -wt2[1].v[k];
922  v[ID4].v[k] += wt1[0].v[k];
923  v[1 + ID4].v[k] += wt1[1].v[k];
924  }
925  }
926 
927 
928  inline void set_sp4_ym(svbool_t pg, Vsimd_t *v,
929  svreal_t wt1r, svreal_t wt1i,
930  svreal_t wt2r, svreal_t wt2i, int ic)
931  {
932  int ic2 = ND * 2 * ic;
933  svreal_t vtr, vti;
934  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
935  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
936  vtr = svadd_m(pg, vtr, wt1r);
937  vti = svadd_m(pg, vti, wt1i);
938  svst1(pg, &v[ic2 + ID1].v[0], vtr);
939  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
940 
941  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
942  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
943  vtr = svadd_m(pg, vtr, wt2r);
944  vti = svadd_m(pg, vti, wt2i);
945  svst1(pg, &v[ic2 + ID2].v[0], vtr);
946  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
947 
948  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
949  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
950  vtr = svsub_m(pg, vtr, wt2r);
951  vti = svsub_m(pg, vti, wt2i);
952  svst1(pg, &v[ic2 + ID3].v[0], vtr);
953  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
954 
955  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
956  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
957  vtr = svadd_m(pg, vtr, wt1r);
958  vti = svadd_m(pg, vti, wt1i);
959  svst1(pg, &v[ic2 + ID4].v[0], vtr);
960  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
961  }
962 
963 
964  inline void set_sp4_ym(svbool_t pg, real_t *v,
965  svreal_t wt1r, svreal_t wt1i,
966  svreal_t wt2r, svreal_t wt2i, int ic)
967  {
968  int ic2 = ND * 2 * ic;
969  svreal_t vtr, vti;
970  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
971  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
972  vtr = svadd_m(pg, vtr, wt1r);
973  vti = svadd_m(pg, vti, wt1i);
974  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
975  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
976 
977  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
978  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
979  vtr = svadd_m(pg, vtr, wt2r);
980  vti = svadd_m(pg, vti, wt2i);
981  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
982  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
983 
984  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
985  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
986  vtr = svsub_m(pg, vtr, wt2r);
987  vti = svsub_m(pg, vti, wt2i);
988  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
989  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
990 
991  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
992  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
993  vtr = svadd_m(pg, vtr, wt1r);
994  vti = svadd_m(pg, vti, wt1i);
995  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
996  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
997  }
998 
999 
1000  inline void set_sp4_zp(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
1001  {
1002  for (int k = 0; k < VLEN; ++k) {
1003  v[ID1].v[k] += wt1[0].v[k];
1004  v[1 + ID1].v[k] += wt1[1].v[k];
1005  v[ID2].v[k] += wt2[0].v[k];
1006  v[1 + ID2].v[k] += wt2[1].v[k];
1007  v[ID3].v[k] += -wt1[1].v[k];
1008  v[1 + ID3].v[k] += wt1[0].v[k];
1009  v[ID4].v[k] += wt2[1].v[k];
1010  v[1 + ID4].v[k] += -wt2[0].v[k];
1011  }
1012  }
1013 
1014 
1015  inline void set_sp4_zp(svbool_t pg, Vsimd_t *v,
1016  svreal_t wt1r, svreal_t wt1i,
1017  svreal_t wt2r, svreal_t wt2i, int ic)
1018  {
1019  int ic2 = ND * 2 * ic;
1020  svreal_t vtr, vti;
1021  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
1022  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
1023  vtr = svadd_m(pg, vtr, wt1r);
1024  vti = svadd_m(pg, vti, wt1i);
1025  svst1(pg, &v[ic2 + ID1].v[0], vtr);
1026  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
1027 
1028  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
1029  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
1030  vtr = svadd_m(pg, vtr, wt2r);
1031  vti = svadd_m(pg, vti, wt2i);
1032  svst1(pg, &v[ic2 + ID2].v[0], vtr);
1033  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
1034 
1035  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
1036  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
1037  vtr = svsub_m(pg, vtr, wt1i);
1038  vti = svadd_m(pg, vti, wt1r);
1039  svst1(pg, &v[ic2 + ID3].v[0], vtr);
1040  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
1041 
1042  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
1043  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
1044  vtr = svadd_m(pg, vtr, wt2i);
1045  vti = svsub_m(pg, vti, wt2r);
1046  svst1(pg, &v[ic2 + ID4].v[0], vtr);
1047  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
1048  }
1049 
1050 
1051  inline void set_sp4_zp(svbool_t pg, real_t *v,
1052  svreal_t wt1r, svreal_t wt1i,
1053  svreal_t wt2r, svreal_t wt2i, int ic)
1054  {
1055  int ic2 = ND * 2 * ic;
1056  svreal_t vtr, vti;
1057  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
1058  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
1059  vtr = svadd_m(pg, vtr, wt1r);
1060  vti = svadd_m(pg, vti, wt1i);
1061  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
1062  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
1063 
1064  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
1065  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
1066  vtr = svadd_m(pg, vtr, wt2r);
1067  vti = svadd_m(pg, vti, wt2i);
1068  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
1069  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
1070 
1071  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
1072  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
1073  vtr = svsub_m(pg, vtr, wt1i);
1074  vti = svadd_m(pg, vti, wt1r);
1075  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
1076  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
1077 
1078  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
1079  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
1080  vtr = svadd_m(pg, vtr, wt2i);
1081  vti = svsub_m(pg, vti, wt2r);
1082  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
1083  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
1084  }
1085 
1086 
1087  inline void set_sp4_zm(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
1088  {
1089  for (int k = 0; k < VLEN; ++k) {
1090  v[ID1].v[k] += wt1[0].v[k];
1091  v[1 + ID1].v[k] += wt1[1].v[k];
1092  v[ID2].v[k] += wt2[0].v[k];
1093  v[1 + ID2].v[k] += wt2[1].v[k];
1094  v[ID3].v[k] += wt1[1].v[k];
1095  v[1 + ID3].v[k] += -wt1[0].v[k];
1096  v[ID4].v[k] += -wt2[1].v[k];
1097  v[1 + ID4].v[k] += wt2[0].v[k];
1098  }
1099  }
1100 
1101 
1102  inline void set_sp4_zm(svbool_t pg, Vsimd_t *v,
1103  svreal_t wt1r, svreal_t wt1i,
1104  svreal_t wt2r, svreal_t wt2i, int ic)
1105  {
1106  int ic2 = ND * 2 * ic;
1107  svreal_t vtr, vti;
1108  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
1109  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
1110  vtr = svadd_m(pg, vtr, wt1r);
1111  vti = svadd_m(pg, vti, wt1i);
1112  svst1(pg, &v[ic2 + ID1].v[0], vtr);
1113  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
1114 
1115  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
1116  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
1117  vtr = svadd_m(pg, vtr, wt2r);
1118  vti = svadd_m(pg, vti, wt2i);
1119  svst1(pg, &v[ic2 + ID2].v[0], vtr);
1120  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
1121 
1122  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
1123  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
1124  vtr = svadd_m(pg, vtr, wt1i);
1125  vti = svsub_m(pg, vti, wt1r);
1126  svst1(pg, &v[ic2 + ID3].v[0], vtr);
1127  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
1128 
1129  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
1130  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
1131  vtr = svsub_m(pg, vtr, wt2i);
1132  vti = svadd_m(pg, vti, wt2r);
1133  svst1(pg, &v[ic2 + ID4].v[0], vtr);
1134  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
1135  }
1136 
1137 
1138  inline void set_sp4_zm(svbool_t pg, real_t *v,
1139  svreal_t wt1r, svreal_t wt1i,
1140  svreal_t wt2r, svreal_t wt2i, int ic)
1141  {
1142  int ic2 = ND * 2 * ic;
1143  svreal_t vtr, vti;
1144  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
1145  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
1146  vtr = svadd_m(pg, vtr, wt1r);
1147  vti = svadd_m(pg, vti, wt1i);
1148  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
1149  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
1150 
1151  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
1152  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
1153  vtr = svadd_m(pg, vtr, wt2r);
1154  vti = svadd_m(pg, vti, wt2i);
1155  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
1156  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
1157 
1158  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
1159  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
1160  vtr = svadd_m(pg, vtr, wt1i);
1161  vti = svsub_m(pg, vti, wt1r);
1162  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
1163  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
1164 
1165  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
1166  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
1167  vtr = svsub_m(pg, vtr, wt2i);
1168  vti = svadd_m(pg, vti, wt2r);
1169  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
1170  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
1171  }
1172 
1173 
1174  inline void set_sp4_tp_dirac(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
1175  {
1176  for (int k = 0; k < VLEN; ++k) {
1177  v[ID3].v[k] += wt1[0].v[k];
1178  v[1 + ID3].v[k] += wt1[1].v[k];
1179  v[ID4].v[k] += wt2[0].v[k];
1180  v[1 + ID4].v[k] += wt2[1].v[k];
1181  }
1182  }
1183 
1184 
1185  inline void set_sp4_tp_dirac(svbool_t pg, real_t *v,
1186  svreal_t wt1r, svreal_t wt1i,
1187  svreal_t wt2r, svreal_t wt2i, int ic)
1188  {
1189  int ic2 = ND * 2 * ic;
1190  svreal_t vtr, vti;
1191  load_vec(pg, vtr, &v[VLEN * (ic2 + ID3)]);
1192  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID3)]);
1193  vtr = svadd_m(pg, vtr, wt1r);
1194  vti = svadd_m(pg, vti, wt1i);
1195  svst1(pg, &v[VLEN * (ic2 + ID3)], vtr);
1196  svst1(pg, &v[VLEN * (ic2 + 1 + ID3)], vti);
1197 
1198  load_vec(pg, vtr, &v[VLEN * (ic2 + ID4)]);
1199  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID4)]);
1200  vtr = svadd_m(pg, vtr, wt2r);
1201  vti = svadd_m(pg, vti, wt2i);
1202  svst1(pg, &v[VLEN * (ic2 + ID4)], vtr);
1203  svst1(pg, &v[VLEN * (ic2 + 1 + ID4)], vti);
1204  }
1205 
1206 
1207  inline void set_sp4_tp_dirac(svbool_t pg, Vsimd_t *v,
1208  svreal_t wt1r, svreal_t wt1i,
1209  svreal_t wt2r, svreal_t wt2i, int ic)
1210  {
1211  int ic2 = ND * 2 * ic;
1212  svreal_t vtr, vti;
1213  load_vec(pg, vtr, &v[ic2 + ID3].v[0]);
1214  load_vec(pg, vti, &v[ic2 + 1 + ID3].v[0]);
1215  vtr = svadd_m(pg, vtr, wt1r);
1216  vti = svadd_m(pg, vti, wt1i);
1217  svst1(pg, &v[ic2 + ID3].v[0], vtr);
1218  svst1(pg, &v[ic2 + 1 + ID3].v[0], vti);
1219 
1220  load_vec(pg, vtr, &v[ic2 + ID4].v[0]);
1221  load_vec(pg, vti, &v[ic2 + 1 + ID4].v[0]);
1222  vtr = svadd_m(pg, vtr, wt2r);
1223  vti = svadd_m(pg, vti, wt2i);
1224  svst1(pg, &v[ic2 + ID4].v[0], vtr);
1225  svst1(pg, &v[ic2 + 1 + ID4].v[0], vti);
1226  }
1227 
1228 
1229  inline void set_sp4_tm_dirac(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
1230  {
1231  for (int k = 0; k < VLEN; ++k) {
1232  v[ID1].v[k] += wt1[0].v[k];
1233  v[1 + ID1].v[k] += wt1[1].v[k];
1234  v[ID2].v[k] += wt2[0].v[k];
1235  v[1 + ID2].v[k] += wt2[1].v[k];
1236  }
1237  }
1238 
1239 
1240  inline void set_sp4_tm_dirac(svbool_t pg, Vsimd_t *v,
1241  svreal_t wt1r, svreal_t wt1i,
1242  svreal_t wt2r, svreal_t wt2i, int ic)
1243  {
1244  int ic2 = ND * 2 * ic;
1245  svreal_t vtr, vti;
1246  load_vec(pg, vtr, &v[ic2 + ID1].v[0]);
1247  load_vec(pg, vti, &v[ic2 + 1 + ID1].v[0]);
1248  vtr = svadd_m(pg, vtr, wt1r);
1249  vti = svadd_m(pg, vti, wt1i);
1250  svst1(pg, &v[ic2 + ID1].v[0], vtr);
1251  svst1(pg, &v[ic2 + 1 + ID1].v[0], vti);
1252 
1253  load_vec(pg, vtr, &v[ic2 + ID2].v[0]);
1254  load_vec(pg, vti, &v[ic2 + 1 + ID2].v[0]);
1255  vtr = svadd_m(pg, vtr, wt2r);
1256  vti = svadd_m(pg, vti, wt2i);
1257  svst1(pg, &v[ic2 + ID2].v[0], vtr);
1258  svst1(pg, &v[ic2 + 1 + ID2].v[0], vti);
1259  }
1260 
1261 
1262  inline void set_sp4_tm_dirac(svbool_t pg, real_t *v,
1263  svreal_t wt1r, svreal_t wt1i,
1264  svreal_t wt2r, svreal_t wt2i, int ic)
1265  {
1266  int ic2 = ND * 2 * ic;
1267  svreal_t vtr, vti;
1268  load_vec(pg, vtr, &v[VLEN * (ic2 + ID1)]);
1269  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID1)]);
1270  vtr = svadd_m(pg, vtr, wt1r);
1271  vti = svadd_m(pg, vti, wt1i);
1272  svst1(pg, &v[VLEN * (ic2 + ID1)], vtr);
1273  svst1(pg, &v[VLEN * (ic2 + 1 + ID1)], vti);
1274 
1275  load_vec(pg, vtr, &v[VLEN * (ic2 + ID2)]);
1276  load_vec(pg, vti, &v[VLEN * (ic2 + 1 + ID2)]);
1277  vtr = svadd_m(pg, vtr, wt2r);
1278  vti = svadd_m(pg, vti, wt2i);
1279  svst1(pg, &v[VLEN * (ic2 + ID2)], vtr);
1280  svst1(pg, &v[VLEN * (ic2 + 1 + ID2)], vti);
1281  }
1282 
1283 
1284  inline void mult_gm5_dirac_vec(Vsimd_t *v, Vsimd_t *w, int Nc)
1285  {
1286  for (int ivc = 0; ivc < NVC; ++ivc) {
1287  int ivc2 = (ivc % 2) + 2 * ND * (ivc / 2);
1288  for (int k = 0; k < VLEN; ++k) {
1289  v[ID1 + ivc2].v[k] = -w[ID3 + ivc2].v[k];
1290  v[ID2 + ivc2].v[k] = -w[ID4 + ivc2].v[k];
1291  v[ID3 + ivc2].v[k] = -w[ID1 + ivc2].v[k];
1292  v[ID4 + ivc2].v[k] = -w[ID2 + ivc2].v[k];
1293  }
1294  }
1295  }
1296 
1297 
1298  template<typename REALTYPE>
1299  inline void mult_gm5_dirac_vec(svbool_t pg,
1300  REALTYPE *__restrict v,
1301  REALTYPE *__restrict w)
1302  {
1303  // svbool_t pg = set_predicate();
1304  svreal_t vt1r, vt1i, vt2r, vt2i;
1305  svreal_t vt3r, vt3i, vt4r, vt4i;
1306 
1307  load_vec(pg, vt3r, &w[VLEN * (ID1)]);
1308  load_vec(pg, vt3i, &w[VLEN * (ID1 + 1)]);
1309  flip_sign(pg, vt3r);
1310  flip_sign(pg, vt3i);
1311 
1312  load_vec(pg, vt4r, &w[VLEN * (ID2)]);
1313  load_vec(pg, vt4i, &w[VLEN * (ID2 + 1)]);
1314  flip_sign(pg, vt4r);
1315  flip_sign(pg, vt4i);
1316 
1317  load_vec(pg, vt1r, &w[VLEN * (ID3)]);
1318  load_vec(pg, vt1i, &w[VLEN * (ID3 + 1)]);
1319  flip_sign(pg, vt1r);
1320  flip_sign(pg, vt1i);
1321 
1322  load_vec(pg, vt2r, &w[VLEN * (ID4)]);
1323  load_vec(pg, vt2i, &w[VLEN * (ID4 + 1)]);
1324  flip_sign(pg, vt2r);
1325  flip_sign(pg, vt2i);
1326 
1327  save_vec(pg, &v[VLEN * (ID1)], vt1r);
1328  save_vec(pg, &v[VLEN * (ID1 + 1)], vt1i);
1329  save_vec(pg, &v[VLEN * (ID2)], vt2r);
1330  save_vec(pg, &v[VLEN * (ID2 + 1)], vt2i);
1331  save_vec(pg, &v[VLEN * (ID3)], vt3r);
1332  save_vec(pg, &v[VLEN * (ID3 + 1)], vt3i);
1333  save_vec(pg, &v[VLEN * (ID4)], vt4r);
1334  save_vec(pg, &v[VLEN * (ID4 + 1)], vt4i);
1335  }
1336 
1337 
1338  template<typename REALTYPE>
1339  inline void load_mult_gm5_dirac_vec(Vsimd_t *v, REALTYPE *w, int Nc)
1340  {
1341  for (int ivc = 0; ivc < NVC; ++ivc) {
1342  int ivc2 = (ivc % 2) + 2 * ND * (ivc / 2);
1343  for (int k = 0; k < VLEN; ++k) {
1344  v[ID1 + ivc2].v[k] = -w[k + VLEN * (ID3 + ivc2)];
1345  v[ID2 + ivc2].v[k] = -w[k + VLEN * (ID4 + ivc2)];
1346  v[ID3 + ivc2].v[k] = -w[k + VLEN * (ID1 + ivc2)];
1347  v[ID4 + ivc2].v[k] = -w[k + VLEN * (ID2 + ivc2)];
1348  }
1349  }
1350  }
1351 
1352 
1353  template<typename REALTYPE>
1354  inline void load_mult_gm5_dirac_vec(svbool_t pg,
1355  svreal_t& vt1r, svreal_t& vt1i,
1356  svreal_t& vt2r, svreal_t& vt2i,
1357  svreal_t& vt3r, svreal_t& vt3i,
1358  svreal_t& vt4r, svreal_t& vt4i,
1359  REALTYPE *w)
1360  {
1361  // svbool_t pg = set_predicate();
1362 
1363  load_vec(pg, vt3r, &w[VLEN * (ID1)]);
1364  load_vec(pg, vt3i, &w[VLEN * (ID1 + 1)]);
1365  flip_sign(pg, vt3r);
1366  flip_sign(pg, vt3i);
1367 
1368  load_vec(pg, vt4r, &w[VLEN * (ID2)]);
1369  load_vec(pg, vt4i, &w[VLEN * (ID2 + 1)]);
1370  flip_sign(pg, vt4r);
1371  flip_sign(pg, vt4i);
1372 
1373  load_vec(pg, vt1r, &w[VLEN * (ID3)]);
1374  load_vec(pg, vt1i, &w[VLEN * (ID3 + 1)]);
1375  flip_sign(pg, vt1r);
1376  flip_sign(pg, vt1i);
1377 
1378  load_vec(pg, vt2r, &w[VLEN * (ID4)]);
1379  load_vec(pg, vt2i, &w[VLEN * (ID4 + 1)]);
1380  flip_sign(pg, vt2r);
1381  flip_sign(pg, vt2i);
1382  }
1383 
1384 
1385  template<typename REALTYPE>
1386  inline void load_mult_gm5_dirac_vec(Vsimd_t *v,
1387  REALTYPE a, REALTYPE *w, int Nc)
1388  {
1389  for (int ivc = 0; ivc < NVC; ++ivc) {
1390  int ivc2 = (ivc % 2) + 2 * ND * (ivc / 2);
1391  for (int k = 0; k < VLEN; ++k) {
1392  v[ID1 + ivc2].v[k] = -a * w[k + VLEN * (ID3 + ivc2)];
1393  v[ID2 + ivc2].v[k] = -a * w[k + VLEN * (ID4 + ivc2)];
1394  v[ID3 + ivc2].v[k] = -a * w[k + VLEN * (ID1 + ivc2)];
1395  v[ID4 + ivc2].v[k] = -a * w[k + VLEN * (ID2 + ivc2)];
1396  }
1397  }
1398  }
1399 } // end of nameless namespace
1400 
1401 #endif
1402 //============================================================END=====
ID1
#define ID1
Definition: vsimd_Wilson_SU3_float-inc.h:12
VLEN
#define VLEN
Definition: bridgeQXS_Clover_coarse_double.cpp:12
ID3
#define ID3
Definition: vsimd_Wilson_SU3_float-inc.h:14
Vsimd_t
Definition: vsimd_double-inc.h:13
Isimd_t
Definition: vsimd_double-inc.h:20
real_t
double real_t
Definition: bridgeQXS_Clover_coarse_double.cpp:16
Vsimd_t::v
double v[VLEND]
Definition: vsimd_double-inc.h:15
NC
#define NC
Definition: field_F_imp_SU2-inc.h:2
ND
#define ND
Definition: field_F_imp_SU2-inc.h:5
ID4
#define ID4
Definition: vsimd_Wilson_SU3_float-inc.h:15
VLENY
#define VLENY
Definition: bridgeQXS_Clover_coarse_double.cpp:14
NVC
#define NVC
Definition: fopr_Wilson_impl_SU2-inc.h:15
svbool_t
Definition: vsimd_double-inc.h:30
VLENX
#define VLENX
Definition: bridgeQXS_Clover_coarse_double.cpp:13
ID2
#define ID2
Definition: vsimd_Wilson_SU3_float-inc.h:13