Debian Codegraph @

src/util/math/zquatev/blocked.cc

raw
1 //
2 // ZQUATEV: Diagonalization of quaternionic matrices
3 // File : blocked.cc
4 // Copyright (c) 2016, Toru Shiozaki ([email protected])
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are met:
9 //
10 // 1. Redistributions of source code must retain the above copyright notice, this
11 // list of conditions and the following disclaimer.
12 // 2. Redistributions in binary form must reproduce the above copyright notice,
13 // this list of conditions and the following disclaimer in the documentation
14 // and/or other materials provided with the distribution.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
20 // ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 //
27 // The views and conclusions contained in the software and documentation are those
28 // of the authors and should not be interpreted as representing official policies,
29 // either expressed or implied, of the FreeBSD Project.
30 //
31
32 #include "zquatev.h"
33 #include "f77.h"
34 #include "supermat.h"
35 #include <cassert>
36
37 using namespace std;
38
39 namespace ts {
40 namespace impl {
41
42 void panel_update(const int n, const int nb,
43 complex<double>* const D0, complex<double>* const D1,
44 complex<double>* const Q0, complex<double>* const Q1,
45 const int ld, const int norig, complex<double>* const work_ptr) {
46
47 assert(n > nb+1); // otherwise does not work
48
49 complex<double>* cptr = work_ptr;
50 auto work1_3n = cptr; cptr += (n-1)*3;
51 auto work2_3nb = cptr; cptr += nb*3;
52 auto work3_nb = cptr; cptr += nb;
53 auto work4_nb = cptr; cptr += nb;
54 SuperMatrix<3,3> T(cptr, nb, nb); cptr += 9*nb*nb;
55 SuperMatrix<3,1> R(cptr, nb, nb); cptr += 3*nb*nb;
56 SuperMatrix<1,3> S(cptr, nb, nb); cptr += 3*nb*nb;
57 SuperMatrix<1,2> W(cptr, n-1, nb, n-1, 1); cptr += 2*(n-1)*nb;
58 SuperMatrix<1,3> YD(cptr, n-1, nb, n-1, 1, true, true); cptr += 2*(n-1)*nb + n-1;
59 SuperMatrix<1,3> ZD(cptr, n-1, nb, n-1, 1, true, true); cptr += 2*(n-1)*nb + n-1;
60 SuperMatrix<1,3> YE(cptr, n-1, nb, n-1, 1, true, true); cptr += 2*(n-1)*nb + n-1;
61 SuperMatrix<1,3> ZE(cptr, n-1, nb, n-1, 1, true, true);
62
63 // TODO once the paper is out, add comments with equation numbers.
64 for (int k = 0; k != nb; ++k) {
65 // prepare the k-th column using compact WY-like representation
66 if (k > 0) {
67 SuperMatrix<1,1> d(D0+k*ld+1, n-1, 1, n-1, 1, false);
68 SuperMatrix<1,1> e(D1+k*ld+1, n-1, 1, n-1, 1, false);
69
70 SuperMatrix<3,1> x(work2_3nb, W.mptr(0), 1, W.mptr(0), 1);
71 x.nptr(2) = 1;
72 SuperMatrix<2,1> x2 = x.trunc<2>();
73 W.cut_row<0>(k-1, x2);
74 x.data<2,0>(0,0) = 1.0;
75 contract<_N>(1.0, YD, x, d);
76 contract<_N>(1.0, YE, x, e);
77
78 SuperMatrix<1,1> y(work1_3n, n-1, 1);
79 contract<_N>(1.0, ZE, x, y);
80 d.add_lastcolumn<0>(y);
81 y.reset();
82 contract<_N>(-1.0, ZD, x, y);
83 e.add_lastcolumn<0>(y);
84
85 const int sf = k-1;
86 auto ds = d.shift(sf);
87 auto es = e.shift(sf);
88 auto Ws = W.shift(sf);
89 SuperMatrix<3,1> y1(work1_3n, k, 1, k, 1);
90 y1.nptr(0) = W.mptr(0);
91 y1.nptr(1) = W.mptr(1);
92 auto y1s = y1.trunc<2>();
93 contract<_C>(1.0, W, d, y1s);
94 zaxpy_(k, 1.0, d.block(0,0), 1, y1.ptr<2,0>(0,0), 1);
95 SuperMatrix<3,1> y2(work2_3nb, k, 1);
96 contract_tr<_C>(1.0, T, y1, y2, work4_nb);
97 contract<_N>(1.0, Ws, y2.trunc<2>(), ds);
98 ds.data<0,0>(0,0) += y2.data<2,0>(k-1,0);
99 SuperMatrix<1,1> y3(work3_nb, k, 1);
100 contract_tr<_C>(1.0, R, y1, y3, work4_nb);
101 y3.conj();
102 y2.reset();
103 contract_tr<_C>(1.0, S, y3, y2, work4_nb);
104 SuperMatrix<1,1> y4(work1_3n, n-sf, 1);
105 contract<_N>(1.0, Ws, y2.trunc<2>(), y4);
106 y4.data<0,0>(0,0) += y2.data<2,0>(k-1,0);
107 y4.conj();
108
109 SuperMatrix<3,1> y5(work2_3nb, k, 1, k, 1);
110 y5.nptr(0) = W.mptr(0);
111 y5.nptr(1) = W.mptr(1);
112 auto y5s = y5.trunc<2>();
113 contract<_T>(1.0, W, e, y5s);
114 zaxpy_(k, 1.0, e.block(0,0), 1, y5.ptr<2,0>(0,0), 1);
115 es.add_lastcolumn<0>(y4);
116
117 SuperMatrix<3,1> y5x(work1_3n, y5);
118 SuperMatrix<1,1> y6(work3_nb, k, 1);
119 contract_tr<_T>(1.0, R, y5x, y6, work4_nb);
120 SuperMatrix<3,1> y7(work2_3nb, k, 1);
121 contract_tr<_C>(1.0, S, y6, y7, work4_nb);
122 contract<_N>(-1.0, Ws, y7.trunc<2>(), ds);
123 ds.data<0,0>(0,0) -= y7.data<2,0>(k-1,0);
124 y7.reset();
125 contract_tr<_T>(1.0, T, y5x, y7, work4_nb);
126 y7.conj();
127 SuperMatrix<1,1> y8(work1_3n, n-sf, 1);
128 contract<_N>(1.0, Ws, y7.trunc<2>(), y8);
129 y8.data<0,0>(0,0) += y7.data<2,0>(k-1,0);
130 y8.conj();
131 es.add_lastcolumn<0>(y8);
132 }
133 if (k == n-1) break;
134
135 const int len = n-k-1;
136 complex<double> alpha = D1[k*ld+k+1];
137 if (len > 1) {
138 complex<double>* dnow = D1+k*ld+k+1;
139 complex<double> tau;
140 dnow[0] = 1.0;
141 zlarfg_(len, alpha, dnow+1, 1, tau);
142 tau = conj(tau);
143 conj_n(dnow, len);
144
145 if (k == 0) {
146 W.write_lastcolumn<0>(dnow, len);
147 T.data<0,0>(0,0) = -tau;
148 zgemv_("N", len, len, -tau, D0+ld+1, ld, dnow, 1, 0.0, YD.block(0,0), 1);
149 zgemv_("N", len, len, -tau, D1+ld+1, ld, dnow, 1, 0.0, YE.block(0,0), 1);
150
151 zaxpy_(len, -conj(tau)*zdotc_(len, dnow, 1, D0+1, 1), dnow, 1, D0+1, 1);
152 } else {
153 R.append_row<0>();
154 SuperMatrix<2,1> x(work2_3nb, k, 1);
155
156 SuperMatrix<1,1> v(work1_3n, n-k-1, 1, n-k-1, 1);
157 v.write_lastcolumn<0>(dnow, len);
158 contract<_C>(-tau, W.shift(k), v, x);
159
160 SuperMatrix<3,1> v2(work1_3n, k, 1);
161 contract_tr<_N>(1.0, T.slice<0,2>(), x, v2, work4_nb);
162 T.append_column<0>(v2);
163 T.append_row<0,0>(k, -tau);
164
165 SuperMatrix<1,1> v3(work3_nb, k, 1);
166 contract_tr<_N>(1.0, S.slice<0,2>(), x, v3, work4_nb);
167 S.append_column<0>(v3);
168 W.append_column<0>(dnow, len, k);
169
170 SuperMatrix<1,1> yx(work1_3n, n-1, 1);
171 contract<_N>(1.0, YD.slice<0,2>(), x, yx);
172 YD.append_column<0>(yx);
173 zgemv_("N", n-1, len, -tau, D0+(k+1)*ld+1, ld, dnow, 1, 1.0, YD.ptr<0,0>(0,k), 1);
174 yx.reset();
175 contract<_N>(1.0, YE.slice<0,2>(), x, yx);
176 YE.append_column<0>(yx);
177 zgemv_("N", n-1, len, -tau, D1+(k+1)*ld+1, ld, dnow, 1, 1.0, YE.ptr<0,0>(0,k), 1);
178 yx.reset();
179 contract<_N>(1.0, ZD.slice<0,2>(), x, yx);
180 ZD.append_column<0>(yx);
181 yx.reset();
182 contract<_N>(1.0, ZE.slice<0,2>(), x, yx);
183 ZE.append_column<0>(yx);
184
185 zaxpy_(len, -conj(tau)*zdotc_(len, dnow, 1, D0+k*ld+k+1, 1), dnow, 1, D0+k*ld+k+1, 1);
186 }
187 }
188
189 double c;
190 complex<double> s, dum;
191 zlartg_(D0[k+1+k*ld], alpha, c, s, dum);
192 assert(abs(-conj(s)*D0[k+1+k*ld]+c*alpha) < 1.0e-10);
193 D0[k+1+k*ld] = c*D0[k+1+k*ld] + s*alpha;
194
195 const double cbar = c-1.0;
196 const complex<double> sbar = conj(s);
197 if (k == 0) {
198 assert(abs(W.data<0,0>(0,0)-1.0)<1.0e-10);
199 T.data<0,2>(0,0) = T.data<0,0>(0,0)*cbar;
200 T.data<2,2>(0,0) = cbar;
201 R.data<0,0>(0,0) = T.data<0,0>(0,0);
202 R.data<2,0>(0,0) = 1.0;
203 S.data<0,2>(0,0) = -sbar;
204
205 auto YD0 = YD.slice<0>();
206 auto YE0 = YE.slice<0>();
207 YD.add_lastcolumn<2>(YD0, cbar);
208 YE.add_lastcolumn<2>(YE0, cbar);
209 zaxpy_(n-1, cbar, D0+ld+1, 1, YD.block(0,2), 1);
210 zaxpy_(n-1, cbar, D1+ld+1, 1, YE.block(0,2), 1);
211 SuperMatrix<1,1> yd0b(work1_3n, YD0);
212 SuperMatrix<1,1> ye0b(work1_3n+n-1, YE0);
213 zaxpy_(n-1, 1.0, D0+ld+1, 1, yd0b.block(0,0), 1);
214 zaxpy_(n-1, 1.0, D1+ld+1, 1, ye0b.block(0,0), 1);
215 yd0b.conj();
216 ye0b.conj();
217 ZD.add_lastcolumn<2>(yd0b, -sbar);
218 ZE.add_lastcolumn<2>(ye0b, -sbar);
219 } else {
220 SuperMatrix<2,1> x(work2_3nb, k+1, 1);
221 W.cut_row<0>(k, x);
222
223 SuperMatrix<1,1> yx(work1_3n, n-1, 1);
224 SuperMatrix<1,1> zx(work1_3n+n-1, n-1, 1);
225 contract<_N>(1.0, YD.slice<0,2>(), x, yx);
226 contract<_N>(1.0, ZD.slice<0,2>(), x, zx);
227 fill_n(YD.block(0,2), n-1, 0.0);
228 fill_n(ZD.block(0,2), n-1, 0.0);
229 ZD.add_lastcolumn<2>(zx, cbar);
230 zx.conj();
231 YD.add_lastcolumn<2>(zx, sbar);
232 zaxpy_(n-1, 1.0, D0+(k+1)*ld+1, 1, yx.block(0,0), 1);
233 YD.add_lastcolumn<2>(yx, cbar);
234 yx.conj();
235 ZD.add_lastcolumn<2>(yx, -sbar);
236
237 yx.reset();
238 zx.reset();
239 contract<_N>(1.0, YE.slice<0,2>(), x, yx);
240 contract<_N>(1.0, ZE.slice<0,2>(), x, zx);
241 fill_n(YE.block(0,2), n-1, 0.0);
242 fill_n(ZE.block(0,2), n-1, 0.0);
243 ZE.add_lastcolumn<2>(zx, cbar);
244 zx.conj();
245 YE.add_lastcolumn<2>(zx, sbar);
246 zaxpy_(n-1, 1.0, D1+(k+1)*ld+1, 1, yx.block(0,0), 1);
247 YE.add_lastcolumn<2>(yx, cbar);
248 yx.conj();
249 ZE.add_lastcolumn<2>(yx, -sbar);
250
251 SuperMatrix<3,1> v(work1_3n, k+1, 1);
252 contract_tr<_N>(1.0, T.slice<0,2>(), x, v, work4_nb);
253 SuperMatrix<1,1> y(work3_nb, k+1, 1);
254 contract_tr<_N>(1.0, S.slice<0,2>(), x, y, work4_nb);
255 y.conj();
256 SuperMatrix<3,1> z(work2_3nb, k+1, 1);
257 contract_tr<_N>(sbar, R, y, z, work4_nb);
258 y.conj();
259 T.append_column<2>(z);
260 T.add_lastcolumn<2>(v, cbar);
261 T.append_row<2,2>(k, cbar);
262
263 R.append_column<0>(v);
264 R.append_row<2,0>(k,1.0);
265 y.scale(cbar);
266 S.append_column<2>(y);
267 S.append_row<0,2>(k, -sbar);
268 }
269
270 if (len > 1) {
271 complex<double>* dnow = D0+k*ld+k+1;
272 complex<double> ctau;
273 complex<double> alpha2 = dnow[0];
274 dnow[0] = 1.0;
275 zlarfg_(len, alpha2, dnow+1, 1, ctau);
276
277 if (k == 0) {
278 W.write_lastcolumn<1>(dnow, len);
279 const complex<double> zz = -ctau*zdotc_(len, W.block(0,0), 1, dnow, 1);
280 T.data<0,1>(0,0) = zz*T.data<0,0>(0,0) -ctau*T.data<0,2>(0,0);
281 T.data<2,1>(0,0) = -ctau*T.data<2,2>(0,0);
282 T.data<1,1>(0,0) = -ctau;
283 S.data<0,1>(0,0) = -ctau*S.data<0,2>(0,0);
284
285 zgemv_("N", n-1, n-1, -ctau, D0+ld+1, ld, dnow, 1, 0.0, YD.block(0,1), 1);
286 zgemv_("N", n-1, n-1, -ctau, D1+ld+1, ld, dnow, 1, 0.0, YE.block(0,1), 1);
287 YD.add_lastcolumn<1>(YD.slice<0>(), zz);
288 YE.add_lastcolumn<1>(YE.slice<0>(), zz);
289 YD.add_lastcolumn<1>(YD.slice<2>(), -ctau);
290 YE.add_lastcolumn<1>(YE.slice<2>(), -ctau);
291 ZD.add_lastcolumn<1>(ZD.slice<2>(), -ctau);
292 ZE.add_lastcolumn<1>(ZE.slice<2>(), -ctau);
293 } else {
294 R.append_row<1>();
295 SuperMatrix<3,1> x(work2_3nb, k+1, 1, k+1, 1);
296 x.nptr(1) = k;
297
298 SuperMatrix<1,1> v(work1_3n, n-k-1, 1, n-k-1, 1);
299 v.write_lastcolumn<0>(dnow, len);
300 SuperMatrix<2,1> x2 = x.trunc<2>();
301 contract<_C>(-ctau, W.shift(k), v, x2);
302 x.data<2,0>(k,0) = -ctau;
303
304 SuperMatrix<3,1> v2(work1_3n, k+1, 1);
305 contract_tr<_N>(1.0, T, x, v2, work4_nb);
306 T.append_column<1>(v2);
307 T.append_row<1,1>(k, -ctau);
308
309 SuperMatrix<1,1> v3(work3_nb, k+1, 1);
310 contract_tr<_N>(1.0, S, x, v3, work4_nb);
311 S.append_column<1>(v3);
312 W.append_column<1>(dnow, len, k);
313
314 x.data<2,0>(0,0) = -ctau;
315 x.nptr(2) = 1;
316
317 SuperMatrix<1,1> yx(work1_3n, n-1, 1);
318 contract<_N>(1.0, YD, x, yx);
319 YD.append_column<1>(yx);
320 zgemv_("N", n-1, len, -ctau, D0+(k+1)*ld+1, ld, dnow, 1, 1.0, YD.ptr<0,1>(0,k), 1);
321 yx.reset();
322 contract<_N>(1.0, YE, x, yx);
323 YE.append_column<1>(yx);
324 zgemv_("N", n-1, len, -ctau, D1+(k+1)*ld+1, ld, dnow, 1, 1.0, YE.ptr<0,1>(0,k), 1);
325 yx.reset();
326 contract<_N>(1.0, ZD, x, yx);
327 ZD.append_column<1>(yx);
328 yx.reset();
329 contract<_N>(1.0, ZE, x, yx);
330 ZE.append_column<1>(yx);
331 }
332 dnow[0] = alpha2;
333 }
334 }
335
336 // finally update
337 const int nrem = n-nb;
338 if (nrem > 0) {
339 // first update D and E.
340 // Y^D + Z^E
341 zaxpy_((n-1)*(nb*2+1), 1.0, ZE.block(0,0), 1, YD.block(0,0), 1);
342 zaxpy_((n-1)*(nb*2+1), -1.0, ZD.block(0,0), 1, YE.block(0,0), 1);
343 // Multiplied by W^+
344 zgemm3m_("N", "C", n-1, nrem, nb*2, 1.0, YD.block(0,0), n-1, W.block(0,0)+nb-1, n-1, 1.0, D0+nb*ld+1, ld);
345 zgemm3m_("N", "C", n-1, nrem, nb*2, 1.0, YE.block(0,0), n-1, W.block(0,0)+nb-1, n-1, 1.0, D1+nb*ld+1, ld);
346 assert(YD.nptr(0) == n-1 && YD.mptr(2) == 1);
347 zaxpy_(n-1, 1.0, YD.block(0,2), 1, D0+nb*ld+1, 1);
348 zaxpy_(n-1, 1.0, YE.block(0,2), 1, D1+nb*ld+1, 1);
349
350 // now I can destroy Y and Z.
351 complex<double>* const ptr = YD.block(0,0);
352
353 // D^+W
354 SuperMatrix<1,3> DW(ptr, nrem, nb, nrem, nb, /*init*/false); // 3 used
355 zgemm3m_("C", "N", nrem, nb*2, n-1, 1.0, D0+nb*ld+1, ld, W.block(0,0), n-1, 0.0, DW.block(0,0), nrem);
356 transpose_conj(nb, nrem, D0+nb*ld+1, ld, DW.block(0,2), nrem);
357 // E^TW
358 SuperMatrix<1,3> EW(ptr+nrem*nb*3, nrem, nb, nrem, nb, /*init*/false); // 6 used
359 zgemm3m_("T", "N", nrem, nb*2, n-1, 1.0, D1+nb*ld+1, ld, W.block(0,0), n-1, 0.0, EW.block(0,0), nrem);
360 transpose(nb, nrem, D1+nb*ld+1, ld, EW.block(0,2), nrem);
361
362 // WT^+
363 SuperMatrix<1,3> WT(ptr+nrem*nb*6, nrem, nb, nrem, nb, /*init*/true); // 9 used
364 contract<_N, _C>(1.0, W.shift(nb-1), T.slice<0,2>(), WT);
365 for (int i = 0; i != nb; ++i) {
366 WT.data<0,0>(0,i) += conj(T.data<0,2>(i,nb-1));
367 WT.data<0,1>(0,i) += conj(T.data<1,2>(i,nb-1));
368 WT.data<0,2>(0,i) += conj(T.data<2,2>(i,nb-1));
369 }
370
371 // D <- WT^+W^+D
372 zgemm3m_("N", "C", nrem, nrem, nb*3, 1.0, WT.block(0,0), nrem, DW.block(0,0), nrem, 1.0, D0+nb*ld+nb, ld);
373 // E <- W^*T^T W^TE
374 conj_n(WT.block(0,0), nrem*nb*3);
375 zgemm3m_("N", "T", nrem, nrem, nb*3, 1.0, WT.block(0,0), nrem, EW.block(0,0), nrem, 1.0, D1+nb*ld+nb, ld);
376
377 // next first form WS^+
378 SuperMatrix<1,1> WS(ptr+nrem*nb*6, nrem, nb, nrem, nb, /*init*/true); // 7 used
379 contract<_N, _C>(1.0, W.shift(nb-1), S.slice<0,2>(), WS);
380 for (int i = 0; i != nb; ++i)
381 WS.data<0,0>(0,i) += conj(S.data<0,2>(i,nb-1));
382
383 // E^T WR
384 SuperMatrix<1,1> EWR(ptr+nrem*nb*7, nrem, nb, nrem, nb, /*init*/true); // 8 used
385 contract<_N, _N>(1.0, EW, R, EWR);
386 // -WS^+ R^T W^T E = -WS^+ (E^T WR)^T
387 zgemm3m_("N", "T", nrem, nrem, nb, -1.0, WS.block(0,0), nrem, EWR.block(0,0), nrem, 1.0, D0+nb*ld+nb, ld);
388
389 // D^+WR
390 SuperMatrix<1,1> DWR(ptr+nrem*nb*7, nrem, nb, nrem, nb, /*init*/true); // 8 used
391 contract<_N, _N>(1.0, DW, R, DWR);
392 // W^* S^T R^+ W^+D = W^* S^T(D^+ WR)^+
393 conj_n(WS.block(0,0), nrem*nb);
394 zgemm3m_("N", "C", nrem, nrem, nb, 1.0, WS.block(0,0), nrem, DWR.block(0,0), nrem, 1.0, D1+nb*ld+nb, ld);
395 }
396
397 if (n != norig) {
398 complex<double>* const ptr = YD.block(0,0);
399 // Q0W
400 SuperMatrix<1,3> Q0W(ptr, norig, nb, norig, nb, /*init*/false); // 3 used
401 zgemm3m_("N", "N", norig, nb*2, n-1, 1.0, Q0+ld, ld, W.block(0,0), n-1, 0.0, Q0W.block(0,0), norig);
402 fill_n(Q0W.block(0,2), norig*nb, 0.0);
403 for (int i = 0; i != nb; ++i)
404 zaxpy_(norig, 1.0, Q0+ld*(i+1), 1, Q0W.block(0,2)+norig*i, 1);
405 // Q1W
406 SuperMatrix<1,3> Q1W(ptr+norig*nb*3, norig, nb, norig, nb, /*init*/false); // 6 used
407 zgemm3m_("N", "N", norig, nb*2, n-1, 1.0, Q1+ld, ld, W.block(0,0), n-1, 0.0, Q1W.block(0,0), norig);
408 fill_n(Q1W.block(0,2), norig*nb, 0.0);
409 for (int i = 0; i != nb; ++i)
410 zaxpy_(norig, 1.0, Q1+ld*(i+1), 1, Q1W.block(0,2)+norig*i, 1);
411
412 // WT^+
413 SuperMatrix<1,3> WT(ptr+norig*nb*6, n-1, nb, n-1, nb, /*init*/true); // 9 used
414 transpose_conj(nb, nb, T.block(0,2), nb, WT.block(0,0), n-1);
415 transpose_conj(nb, nb, T.block(1,2), nb, WT.block(0,1), n-1);
416 transpose_conj(nb, nb, T.block(2,2), nb, WT.block(0,2), n-1);
417 contract<_N, _C>(1.0, W, T.slice<0,2>(), WT);
418
419 // Q0 <- Q0WTW^+ and Q1 <- Q1WTW^+
420 zgemm3m_("N", "C", norig, n-1, 3*nb, 1.0, Q0W.block(0,0), norig, WT.block(0,0), n-1, 1.0, Q0+ld, ld);
421 zgemm3m_("N", "C", norig, n-1, 3*nb, 1.0, Q1W.block(0,0), norig, WT.block(0,0), n-1, 1.0, Q1+ld, ld);
422
423 // next first form WS^+
424 SuperMatrix<1,1> WS(ptr+norig*nb*6, n-1, nb, n-1, nb, /*init*/true); // 7 used
425 transpose_conj(nb, nb, S.block(0,2), nb, WS.block(0,0), n-1);
426 contract<_N, _C>(1.0, W, S.slice<0,2>(), WS);
427
428 // R^T W^T Q0^T
429 SuperMatrix<1,1> RWQ0(ptr+norig*nb*6+(n-1)*nb, nb, norig, nb, norig, /*init*/true); // 8 used
430 contract<_T, _T>(1.0, R, Q0W, RWQ0);
431 // Q1 <- Q0^* W^* R^* SW^+
432 zgemm3m_("C", "C", norig, n-1, nb, -1.0, RWQ0.block(0,0), nb, WS.block(0,0), n-1, 1.0, Q1+ld, ld);
433
434 // R^T W^T Q1^T
435 SuperMatrix<1,1> RWQ1(ptr+norig*nb*6+(n-1)*nb, nb, norig, nb, norig, /*init*/true); // 8 used
436 contract<_T, _T>(1.0, R, Q1W, RWQ1);
437 // Q0 <- Q1^* W^* R^* SW^+
438 zgemm3m_("C", "C", norig, n-1, nb, 1.0, RWQ1.block(0,0), nb, WS.block(0,0), n-1, 1.0, Q0+ld, ld);
439 } else {
440 // in the first run this can be simplified, because Q0 = unit, Q1 = 0 on input.
441 assert(abs(zdotc_(n*n, Q0, 1, Q0, 1)-static_cast<double>(n)) < 1.0e-10
442 && abs(zdotc_(n*n, Q1, 1, Q1, 1)) < 1.0e-10);
443
444 complex<double>* const ptr = YD.block(0,0);
445 SuperMatrix<1,3> WT(ptr, n-1, nb, n-1, nb, /*init*/true);
446 transpose_conj(nb, nb, T.block(0,2), nb, WT.block(0,0), n-1);
447 transpose_conj(nb, nb, T.block(1,2), nb, WT.block(0,1), n-1);
448 transpose_conj(nb, nb, T.block(2,2), nb, WT.block(0,2), n-1);
449 contract<_N, _C>(1.0, W, T.slice<0,2>(), WT);
450
451 transpose_conj(n-1, nb, WT.block(0,2), n-1, Q0+ld+1, ld);
452 for (int i = 0; i != nb; ++i)
453 Q0[(i+1)*ld+i+1] += 1.0;
454 zgemm3m_("N", "C", n-1, n-1, 2*nb, 1.0, W.block(0,0), n-1, WT.block(0,0), n-1, 1.0, Q0+ld+1, ld);
455
456 SuperMatrix<1,1> WS(ptr, n-1, nb, n-1, nb, /*init*/true);
457 transpose_conj(nb, nb, S.block(0,2), nb, WS.block(0,0), n-1);
458 contract<_N, _C>(1.0, W, S.slice<0,2>(), WS);
459
460 SuperMatrix<1,1> RW(ptr+(n-1)*nb, nb, n-1, nb, n-1, /*init*/true);
461 transpose(nb, nb, R.block(2,0), nb, RW.block(0,0), nb);
462 contract<_T, _T>(1.0, R.trunc<2>(), W, RW);
463 zgemm3m_("C", "C", n-1, n-1, nb, -1.0, RW.block(0,0), nb, WS.block(0,0), n-1, 1.0, Q1+ld+1, ld);
464 }
465
466 }
467
468 } }