1 #include "blas_extended.h"
2 #include "blas_extended_private.h"
3
BLAS_ztpmv_c_x(enum blas_order_type order,enum blas_uplo_type uplo,enum blas_trans_type trans,enum blas_diag_type diag,int n,const void * alpha,const void * tp,void * x,int incx,enum blas_prec_type prec)4 void BLAS_ztpmv_c_x(enum blas_order_type order, enum blas_uplo_type uplo,
5 enum blas_trans_type trans, enum blas_diag_type diag,
6 int n, const void *alpha, const void *tp,
7 void *x, int incx, enum blas_prec_type prec)
8
9 /*
10 * Purpose
11 * =======
12 *
13 * Computes x = alpha * tp * x, x = alpha * tp_transpose * x,
14 * or x = alpha * tp_conjugate_transpose where tp is a triangular
15 * packed matrix.
16 *
17 * Arguments
18 * =========
19 *
20 * order (input) blas_order_type
21 * Order of tp; row or column major
22 *
23 * uplo (input) blas_uplo_type
24 * Whether tp is upper or lower
25 *
26 * trans (input) blas_trans_type
27 *
28 * diag (input) blas_diag_type
29 * Whether the diagonal entries of tp are 1
30 *
31 * n (input) int
32 * Dimension of tp and the length of vector x
33 *
34 * alpha (input) const void*
35 *
36 * tp (input) void*
37 *
38 * x (input) void*
39 *
40 * incx (input) int
41 * The stride for vector x.
42 *
43 * prec (input) enum blas_prec_type
44 * Specifies the internal precision to be used.
45 * = blas_prec_single: single precision.
46 * = blas_prec_double: double precision.
47 * = blas_prec_extra : anything at least 1.5 times as accurate
48 * than double, and wider than 80-bits.
49 * We use double-double in our implementation.
50 *
51 */
52 {
53 static const char routine_name[] = "BLAS_ztpmv_c_x";
54
55
56 switch (prec) {
57 case blas_prec_single:
58 case blas_prec_double:
59 case blas_prec_indigenous:{
60
61 {
62 int matrix_row, step, tp_index, tp_start, x_index, x_start;
63 int inctp, x_index2, stride, col_index, inctp2;
64
65 double *alpha_i = (double *) alpha;
66
67 const float *tp_i = (float *) tp;
68 double *x_i = (double *) x;
69 double rowsum[2];
70 double rowtmp[2];
71 double result[2];
72 float matval[2];
73 double vecval[2];
74 float one[2];
75
76
77 one[0] = 1.0;
78 one[1] = 0.0;
79
80 inctp = 1;
81 inctp *= 2;
82 incx *= 2;
83
84 if (incx < 0)
85 x_start = (-n + 1) * incx;
86 else
87 x_start = 0;
88
89 if (n < 1) {
90 return;
91 }
92
93 /* Check for error conditions. */
94 if (order != blas_colmajor && order != blas_rowmajor) {
95 BLAS_error(routine_name, -1, order, NULL);
96 }
97 if (uplo != blas_upper && uplo != blas_lower) {
98 BLAS_error(routine_name, -2, uplo, NULL);
99 }
100 if (incx == 0) {
101 BLAS_error(routine_name, -9, incx, NULL);
102 }
103
104
105
106 {
107 if ((uplo == blas_upper &&
108 trans == blas_no_trans && order == blas_rowmajor) ||
109 (uplo == blas_lower &&
110 trans != blas_no_trans && order == blas_colmajor)) {
111 tp_start = 0;
112 tp_index = tp_start;
113 for (matrix_row = 0; matrix_row < n; matrix_row++) {
114 x_index = x_start + incx * matrix_row;
115 x_index2 = x_index;
116 col_index = matrix_row;
117 rowsum[0] = rowsum[1] = 0.0;
118 rowtmp[0] = rowtmp[1] = 0.0;
119 result[0] = result[1] = 0.0;
120 while (col_index < n) {
121 vecval[0] = x_i[x_index];
122 vecval[1] = x_i[x_index + 1];
123 if ((diag == blas_unit_diag) && (col_index == matrix_row)) {
124 {
125 rowtmp[0] =
126 (double) vecval[0] * one[0] -
127 (double) vecval[1] * one[1];
128 rowtmp[1] =
129 (double) vecval[0] * one[1] +
130 (double) vecval[1] * one[0];
131 }
132 } else {
133 matval[0] = tp_i[tp_index];
134 matval[1] = tp_i[tp_index + 1];
135 {
136 rowtmp[0] =
137 (double) matval[0] * vecval[0] -
138 (double) matval[1] * vecval[1];
139 rowtmp[1] =
140 (double) matval[0] * vecval[1] +
141 (double) matval[1] * vecval[0];
142 }
143 }
144 rowsum[0] = rowsum[0] + rowtmp[0];
145 rowsum[1] = rowsum[1] + rowtmp[1];
146 x_index += incx;
147 tp_index += inctp;
148 col_index++;
149 }
150 {
151 result[0] =
152 (double) rowsum[0] * alpha_i[0] -
153 (double) rowsum[1] * alpha_i[1];
154 result[1] =
155 (double) rowsum[0] * alpha_i[1] +
156 (double) rowsum[1] * alpha_i[0];
157 }
158 x_i[x_index2] = result[0];
159 x_i[x_index2 + 1] = result[1];
160 }
161 } else if ((uplo == blas_upper &&
162 trans == blas_no_trans && order == blas_colmajor) ||
163 (uplo == blas_lower &&
164 trans != blas_no_trans && order == blas_rowmajor)) {
165 tp_start = ((n - 1) * n) / 2;
166 inctp2 = n - 1;
167 x_index2 = x_start;
168 for (matrix_row = 0; matrix_row < n; matrix_row++, inctp2 = n - 1) {
169 x_index = x_start + incx * (n - 1);
170 tp_index = (tp_start + matrix_row) * inctp;
171 col_index = (n - 1) - matrix_row;
172 rowsum[0] = rowsum[1] = 0.0;
173 rowtmp[0] = rowtmp[1] = 0.0;
174 result[0] = result[1] = 0.0;
175 while (col_index >= 0) {
176 vecval[0] = x_i[x_index];
177 vecval[1] = x_i[x_index + 1];
178 if ((diag == blas_unit_diag) && (col_index == 0)) {
179 {
180 rowtmp[0] =
181 (double) vecval[0] * one[0] -
182 (double) vecval[1] * one[1];
183 rowtmp[1] =
184 (double) vecval[0] * one[1] +
185 (double) vecval[1] * one[0];
186 }
187 } else {
188 matval[0] = tp_i[tp_index];
189 matval[1] = tp_i[tp_index + 1];
190 {
191 rowtmp[0] =
192 (double) matval[0] * vecval[0] -
193 (double) matval[1] * vecval[1];
194 rowtmp[1] =
195 (double) matval[0] * vecval[1] +
196 (double) matval[1] * vecval[0];
197 }
198 }
199 rowsum[0] = rowsum[0] + rowtmp[0];
200 rowsum[1] = rowsum[1] + rowtmp[1];
201 x_index -= incx;
202 tp_index -= inctp2 * inctp;
203 inctp2--;
204 col_index--;
205 }
206 {
207 result[0] =
208 (double) rowsum[0] * alpha_i[0] -
209 (double) rowsum[1] * alpha_i[1];
210 result[1] =
211 (double) rowsum[0] * alpha_i[1] +
212 (double) rowsum[1] * alpha_i[0];
213 }
214 x_i[x_index2] = result[0];
215 x_i[x_index2 + 1] = result[1];
216 x_index2 += incx;
217 }
218 } else if ((uplo == blas_lower &&
219 trans == blas_no_trans && order == blas_rowmajor) ||
220 (uplo == blas_upper &&
221 trans != blas_no_trans && order == blas_colmajor)) {
222 tp_start = (n - 1) + ((n - 1) * n) / 2;
223 tp_index = tp_start * inctp;
224 x_index = x_start + (n - 1) * incx;
225
226 for (matrix_row = n - 1; matrix_row >= 0; matrix_row--) {
227 x_index2 = x_index;
228 rowsum[0] = rowsum[1] = 0.0;
229 rowtmp[0] = rowtmp[1] = 0.0;
230 result[0] = result[1] = 0.0;
231 for (step = 0; step <= matrix_row; step++) {
232 vecval[0] = x_i[x_index2];
233 vecval[1] = x_i[x_index2 + 1];
234 if ((diag == blas_unit_diag) && (step == 0)) {
235 {
236 rowtmp[0] =
237 (double) vecval[0] * one[0] -
238 (double) vecval[1] * one[1];
239 rowtmp[1] =
240 (double) vecval[0] * one[1] +
241 (double) vecval[1] * one[0];
242 }
243 } else {
244 matval[0] = tp_i[tp_index];
245 matval[1] = tp_i[tp_index + 1];
246 {
247 rowtmp[0] =
248 (double) matval[0] * vecval[0] -
249 (double) matval[1] * vecval[1];
250 rowtmp[1] =
251 (double) matval[0] * vecval[1] +
252 (double) matval[1] * vecval[0];
253 }
254 }
255 rowsum[0] = rowsum[0] + rowtmp[0];
256 rowsum[1] = rowsum[1] + rowtmp[1];
257 x_index2 -= incx;
258 tp_index -= inctp;
259 }
260 {
261 result[0] =
262 (double) rowsum[0] * alpha_i[0] -
263 (double) rowsum[1] * alpha_i[1];
264 result[1] =
265 (double) rowsum[0] * alpha_i[1] +
266 (double) rowsum[1] * alpha_i[0];
267 }
268 x_i[x_index] = result[0];
269 x_i[x_index + 1] = result[1];
270 x_index -= incx;
271 }
272 } else {
273 tp_start = 0;
274 x_index = x_start + (n - 1) * incx;
275 for (matrix_row = n - 1; matrix_row >= 0; matrix_row--) {
276 tp_index = matrix_row * inctp;
277 x_index2 = x_start;
278 rowsum[0] = rowsum[1] = 0.0;
279 rowtmp[0] = rowtmp[1] = 0.0;
280 result[0] = result[1] = 0.0;
281 stride = n;
282 for (step = 0; step <= matrix_row; step++) {
283 vecval[0] = x_i[x_index2];
284 vecval[1] = x_i[x_index2 + 1];
285 if ((diag == blas_unit_diag) && (step == matrix_row)) {
286 {
287 rowtmp[0] =
288 (double) vecval[0] * one[0] -
289 (double) vecval[1] * one[1];
290 rowtmp[1] =
291 (double) vecval[0] * one[1] +
292 (double) vecval[1] * one[0];
293 }
294 } else {
295 matval[0] = tp_i[tp_index];
296 matval[1] = tp_i[tp_index + 1];
297 {
298 rowtmp[0] =
299 (double) matval[0] * vecval[0] -
300 (double) matval[1] * vecval[1];
301 rowtmp[1] =
302 (double) matval[0] * vecval[1] +
303 (double) matval[1] * vecval[0];
304 }
305 }
306 rowsum[0] = rowsum[0] + rowtmp[0];
307 rowsum[1] = rowsum[1] + rowtmp[1];
308 stride--;
309 tp_index += stride * inctp;
310 x_index2 += incx;
311 }
312 {
313 result[0] =
314 (double) rowsum[0] * alpha_i[0] -
315 (double) rowsum[1] * alpha_i[1];
316 result[1] =
317 (double) rowsum[0] * alpha_i[1] +
318 (double) rowsum[1] * alpha_i[0];
319 }
320 x_i[x_index] = result[0];
321 x_i[x_index + 1] = result[1];
322 x_index -= incx;
323 }
324 }
325 }
326
327
328 }
329 break;
330 }
331
332 case blas_prec_extra:{
333
334 {
335 int matrix_row, step, tp_index, tp_start, x_index, x_start;
336 int inctp, x_index2, stride, col_index, inctp2;
337
338 double *alpha_i = (double *) alpha;
339
340 const float *tp_i = (float *) tp;
341 double *x_i = (double *) x;
342 double head_rowsum[2], tail_rowsum[2];
343 double head_rowtmp[2], tail_rowtmp[2];
344 double head_result[2], tail_result[2];
345 float matval[2];
346 double vecval[2];
347 float one[2];
348
349 FPU_FIX_DECL;
350 one[0] = 1.0;
351 one[1] = 0.0;
352
353 inctp = 1;
354 inctp *= 2;
355 incx *= 2;
356
357 if (incx < 0)
358 x_start = (-n + 1) * incx;
359 else
360 x_start = 0;
361
362 if (n < 1) {
363 return;
364 }
365
366 /* Check for error conditions. */
367 if (order != blas_colmajor && order != blas_rowmajor) {
368 BLAS_error(routine_name, -1, order, NULL);
369 }
370 if (uplo != blas_upper && uplo != blas_lower) {
371 BLAS_error(routine_name, -2, uplo, NULL);
372 }
373 if (incx == 0) {
374 BLAS_error(routine_name, -9, incx, NULL);
375 }
376 FPU_FIX_START;
377
378
379 {
380 if ((uplo == blas_upper &&
381 trans == blas_no_trans && order == blas_rowmajor) ||
382 (uplo == blas_lower &&
383 trans != blas_no_trans && order == blas_colmajor)) {
384 tp_start = 0;
385 tp_index = tp_start;
386 for (matrix_row = 0; matrix_row < n; matrix_row++) {
387 x_index = x_start + incx * matrix_row;
388 x_index2 = x_index;
389 col_index = matrix_row;
390 head_rowsum[0] = head_rowsum[1] = tail_rowsum[0] =
391 tail_rowsum[1] = 0.0;
392 head_rowtmp[0] = head_rowtmp[1] = tail_rowtmp[0] =
393 tail_rowtmp[1] = 0.0;
394 head_result[0] = head_result[1] = tail_result[0] =
395 tail_result[1] = 0.0;
396 while (col_index < n) {
397 vecval[0] = x_i[x_index];
398 vecval[1] = x_i[x_index + 1];
399 if ((diag == blas_unit_diag) && (col_index == matrix_row)) {
400 {
401 double cd[2];
402 cd[0] = (double) one[0];
403 cd[1] = (double) one[1];
404 {
405 /* Compute complex-extra = complex-double * complex-double. */
406 double head_t1, tail_t1;
407 double head_t2, tail_t2;
408 /* Real part */
409 {
410 /* Compute double_double = double * double. */
411 double a1, a2, b1, b2, con;
412
413 con = vecval[0] * split;
414 a1 = con - vecval[0];
415 a1 = con - a1;
416 a2 = vecval[0] - a1;
417 con = cd[0] * split;
418 b1 = con - cd[0];
419 b1 = con - b1;
420 b2 = cd[0] - b1;
421
422 head_t1 = vecval[0] * cd[0];
423 tail_t1 =
424 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
425 a2 * b2;
426 }
427 {
428 /* Compute double_double = double * double. */
429 double a1, a2, b1, b2, con;
430
431 con = vecval[1] * split;
432 a1 = con - vecval[1];
433 a1 = con - a1;
434 a2 = vecval[1] - a1;
435 con = cd[1] * split;
436 b1 = con - cd[1];
437 b1 = con - b1;
438 b2 = cd[1] - b1;
439
440 head_t2 = vecval[1] * cd[1];
441 tail_t2 =
442 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
443 a2 * b2;
444 }
445 head_t2 = -head_t2;
446 tail_t2 = -tail_t2;
447 {
448 /* Compute double-double = double-double + double-double. */
449 double bv;
450 double s1, s2, t1, t2;
451
452 /* Add two hi words. */
453 s1 = head_t1 + head_t2;
454 bv = s1 - head_t1;
455 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
456
457 /* Add two lo words. */
458 t1 = tail_t1 + tail_t2;
459 bv = t1 - tail_t1;
460 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
461
462 s2 += t1;
463
464 /* Renormalize (s1, s2) to (t1, s2) */
465 t1 = s1 + s2;
466 s2 = s2 - (t1 - s1);
467
468 t2 += s2;
469
470 /* Renormalize (t1, t2) */
471 head_t1 = t1 + t2;
472 tail_t1 = t2 - (head_t1 - t1);
473 }
474 head_rowtmp[0] = head_t1;
475 tail_rowtmp[0] = tail_t1;
476 /* Imaginary part */
477 {
478 /* Compute double_double = double * double. */
479 double a1, a2, b1, b2, con;
480
481 con = vecval[1] * split;
482 a1 = con - vecval[1];
483 a1 = con - a1;
484 a2 = vecval[1] - a1;
485 con = cd[0] * split;
486 b1 = con - cd[0];
487 b1 = con - b1;
488 b2 = cd[0] - b1;
489
490 head_t1 = vecval[1] * cd[0];
491 tail_t1 =
492 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
493 a2 * b2;
494 }
495 {
496 /* Compute double_double = double * double. */
497 double a1, a2, b1, b2, con;
498
499 con = vecval[0] * split;
500 a1 = con - vecval[0];
501 a1 = con - a1;
502 a2 = vecval[0] - a1;
503 con = cd[1] * split;
504 b1 = con - cd[1];
505 b1 = con - b1;
506 b2 = cd[1] - b1;
507
508 head_t2 = vecval[0] * cd[1];
509 tail_t2 =
510 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
511 a2 * b2;
512 }
513 {
514 /* Compute double-double = double-double + double-double. */
515 double bv;
516 double s1, s2, t1, t2;
517
518 /* Add two hi words. */
519 s1 = head_t1 + head_t2;
520 bv = s1 - head_t1;
521 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
522
523 /* Add two lo words. */
524 t1 = tail_t1 + tail_t2;
525 bv = t1 - tail_t1;
526 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
527
528 s2 += t1;
529
530 /* Renormalize (s1, s2) to (t1, s2) */
531 t1 = s1 + s2;
532 s2 = s2 - (t1 - s1);
533
534 t2 += s2;
535
536 /* Renormalize (t1, t2) */
537 head_t1 = t1 + t2;
538 tail_t1 = t2 - (head_t1 - t1);
539 }
540 head_rowtmp[1] = head_t1;
541 tail_rowtmp[1] = tail_t1;
542 }
543 }
544 } else {
545 matval[0] = tp_i[tp_index];
546 matval[1] = tp_i[tp_index + 1];
547 {
548 double cd[2];
549 cd[0] = (double) matval[0];
550 cd[1] = (double) matval[1];
551 {
552 /* Compute complex-extra = complex-double * complex-double. */
553 double head_t1, tail_t1;
554 double head_t2, tail_t2;
555 /* Real part */
556 {
557 /* Compute double_double = double * double. */
558 double a1, a2, b1, b2, con;
559
560 con = vecval[0] * split;
561 a1 = con - vecval[0];
562 a1 = con - a1;
563 a2 = vecval[0] - a1;
564 con = cd[0] * split;
565 b1 = con - cd[0];
566 b1 = con - b1;
567 b2 = cd[0] - b1;
568
569 head_t1 = vecval[0] * cd[0];
570 tail_t1 =
571 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
572 a2 * b2;
573 }
574 {
575 /* Compute double_double = double * double. */
576 double a1, a2, b1, b2, con;
577
578 con = vecval[1] * split;
579 a1 = con - vecval[1];
580 a1 = con - a1;
581 a2 = vecval[1] - a1;
582 con = cd[1] * split;
583 b1 = con - cd[1];
584 b1 = con - b1;
585 b2 = cd[1] - b1;
586
587 head_t2 = vecval[1] * cd[1];
588 tail_t2 =
589 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
590 a2 * b2;
591 }
592 head_t2 = -head_t2;
593 tail_t2 = -tail_t2;
594 {
595 /* Compute double-double = double-double + double-double. */
596 double bv;
597 double s1, s2, t1, t2;
598
599 /* Add two hi words. */
600 s1 = head_t1 + head_t2;
601 bv = s1 - head_t1;
602 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
603
604 /* Add two lo words. */
605 t1 = tail_t1 + tail_t2;
606 bv = t1 - tail_t1;
607 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
608
609 s2 += t1;
610
611 /* Renormalize (s1, s2) to (t1, s2) */
612 t1 = s1 + s2;
613 s2 = s2 - (t1 - s1);
614
615 t2 += s2;
616
617 /* Renormalize (t1, t2) */
618 head_t1 = t1 + t2;
619 tail_t1 = t2 - (head_t1 - t1);
620 }
621 head_rowtmp[0] = head_t1;
622 tail_rowtmp[0] = tail_t1;
623 /* Imaginary part */
624 {
625 /* Compute double_double = double * double. */
626 double a1, a2, b1, b2, con;
627
628 con = vecval[1] * split;
629 a1 = con - vecval[1];
630 a1 = con - a1;
631 a2 = vecval[1] - a1;
632 con = cd[0] * split;
633 b1 = con - cd[0];
634 b1 = con - b1;
635 b2 = cd[0] - b1;
636
637 head_t1 = vecval[1] * cd[0];
638 tail_t1 =
639 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
640 a2 * b2;
641 }
642 {
643 /* Compute double_double = double * double. */
644 double a1, a2, b1, b2, con;
645
646 con = vecval[0] * split;
647 a1 = con - vecval[0];
648 a1 = con - a1;
649 a2 = vecval[0] - a1;
650 con = cd[1] * split;
651 b1 = con - cd[1];
652 b1 = con - b1;
653 b2 = cd[1] - b1;
654
655 head_t2 = vecval[0] * cd[1];
656 tail_t2 =
657 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
658 a2 * b2;
659 }
660 {
661 /* Compute double-double = double-double + double-double. */
662 double bv;
663 double s1, s2, t1, t2;
664
665 /* Add two hi words. */
666 s1 = head_t1 + head_t2;
667 bv = s1 - head_t1;
668 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
669
670 /* Add two lo words. */
671 t1 = tail_t1 + tail_t2;
672 bv = t1 - tail_t1;
673 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
674
675 s2 += t1;
676
677 /* Renormalize (s1, s2) to (t1, s2) */
678 t1 = s1 + s2;
679 s2 = s2 - (t1 - s1);
680
681 t2 += s2;
682
683 /* Renormalize (t1, t2) */
684 head_t1 = t1 + t2;
685 tail_t1 = t2 - (head_t1 - t1);
686 }
687 head_rowtmp[1] = head_t1;
688 tail_rowtmp[1] = tail_t1;
689 }
690 }
691 }
692 {
693 double head_t, tail_t;
694 double head_a, tail_a;
695 double head_b, tail_b;
696 /* Real part */
697 head_a = head_rowsum[0];
698 tail_a = tail_rowsum[0];
699 head_b = head_rowtmp[0];
700 tail_b = tail_rowtmp[0];
701 {
702 /* Compute double-double = double-double + double-double. */
703 double bv;
704 double s1, s2, t1, t2;
705
706 /* Add two hi words. */
707 s1 = head_a + head_b;
708 bv = s1 - head_a;
709 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
710
711 /* Add two lo words. */
712 t1 = tail_a + tail_b;
713 bv = t1 - tail_a;
714 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
715
716 s2 += t1;
717
718 /* Renormalize (s1, s2) to (t1, s2) */
719 t1 = s1 + s2;
720 s2 = s2 - (t1 - s1);
721
722 t2 += s2;
723
724 /* Renormalize (t1, t2) */
725 head_t = t1 + t2;
726 tail_t = t2 - (head_t - t1);
727 }
728 head_rowsum[0] = head_t;
729 tail_rowsum[0] = tail_t;
730 /* Imaginary part */
731 head_a = head_rowsum[1];
732 tail_a = tail_rowsum[1];
733 head_b = head_rowtmp[1];
734 tail_b = tail_rowtmp[1];
735 {
736 /* Compute double-double = double-double + double-double. */
737 double bv;
738 double s1, s2, t1, t2;
739
740 /* Add two hi words. */
741 s1 = head_a + head_b;
742 bv = s1 - head_a;
743 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
744
745 /* Add two lo words. */
746 t1 = tail_a + tail_b;
747 bv = t1 - tail_a;
748 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
749
750 s2 += t1;
751
752 /* Renormalize (s1, s2) to (t1, s2) */
753 t1 = s1 + s2;
754 s2 = s2 - (t1 - s1);
755
756 t2 += s2;
757
758 /* Renormalize (t1, t2) */
759 head_t = t1 + t2;
760 tail_t = t2 - (head_t - t1);
761 }
762 head_rowsum[1] = head_t;
763 tail_rowsum[1] = tail_t;
764 }
765 x_index += incx;
766 tp_index += inctp;
767 col_index++;
768 }
769 {
770 /* Compute complex-extra = complex-extra * complex-double. */
771 double head_a0, tail_a0;
772 double head_a1, tail_a1;
773 double head_t1, tail_t1;
774 double head_t2, tail_t2;
775 head_a0 = head_rowsum[0];
776 tail_a0 = tail_rowsum[0];
777 head_a1 = head_rowsum[1];
778 tail_a1 = tail_rowsum[1];
779 /* real part */
780 {
781 /* Compute double-double = double-double * double. */
782 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
783
784 con = head_a0 * split;
785 a11 = con - head_a0;
786 a11 = con - a11;
787 a21 = head_a0 - a11;
788 con = alpha_i[0] * split;
789 b1 = con - alpha_i[0];
790 b1 = con - b1;
791 b2 = alpha_i[0] - b1;
792
793 c11 = head_a0 * alpha_i[0];
794 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
795
796 c2 = tail_a0 * alpha_i[0];
797 t1 = c11 + c2;
798 t2 = (c2 - (t1 - c11)) + c21;
799
800 head_t1 = t1 + t2;
801 tail_t1 = t2 - (head_t1 - t1);
802 }
803 {
804 /* Compute double-double = double-double * double. */
805 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
806
807 con = head_a1 * split;
808 a11 = con - head_a1;
809 a11 = con - a11;
810 a21 = head_a1 - a11;
811 con = alpha_i[1] * split;
812 b1 = con - alpha_i[1];
813 b1 = con - b1;
814 b2 = alpha_i[1] - b1;
815
816 c11 = head_a1 * alpha_i[1];
817 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
818
819 c2 = tail_a1 * alpha_i[1];
820 t1 = c11 + c2;
821 t2 = (c2 - (t1 - c11)) + c21;
822
823 head_t2 = t1 + t2;
824 tail_t2 = t2 - (head_t2 - t1);
825 }
826 head_t2 = -head_t2;
827 tail_t2 = -tail_t2;
828 {
829 /* Compute double-double = double-double + double-double. */
830 double bv;
831 double s1, s2, t1, t2;
832
833 /* Add two hi words. */
834 s1 = head_t1 + head_t2;
835 bv = s1 - head_t1;
836 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
837
838 /* Add two lo words. */
839 t1 = tail_t1 + tail_t2;
840 bv = t1 - tail_t1;
841 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
842
843 s2 += t1;
844
845 /* Renormalize (s1, s2) to (t1, s2) */
846 t1 = s1 + s2;
847 s2 = s2 - (t1 - s1);
848
849 t2 += s2;
850
851 /* Renormalize (t1, t2) */
852 head_t1 = t1 + t2;
853 tail_t1 = t2 - (head_t1 - t1);
854 }
855 head_result[0] = head_t1;
856 tail_result[0] = tail_t1;
857 /* imaginary part */
858 {
859 /* Compute double-double = double-double * double. */
860 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
861
862 con = head_a1 * split;
863 a11 = con - head_a1;
864 a11 = con - a11;
865 a21 = head_a1 - a11;
866 con = alpha_i[0] * split;
867 b1 = con - alpha_i[0];
868 b1 = con - b1;
869 b2 = alpha_i[0] - b1;
870
871 c11 = head_a1 * alpha_i[0];
872 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
873
874 c2 = tail_a1 * alpha_i[0];
875 t1 = c11 + c2;
876 t2 = (c2 - (t1 - c11)) + c21;
877
878 head_t1 = t1 + t2;
879 tail_t1 = t2 - (head_t1 - t1);
880 }
881 {
882 /* Compute double-double = double-double * double. */
883 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
884
885 con = head_a0 * split;
886 a11 = con - head_a0;
887 a11 = con - a11;
888 a21 = head_a0 - a11;
889 con = alpha_i[1] * split;
890 b1 = con - alpha_i[1];
891 b1 = con - b1;
892 b2 = alpha_i[1] - b1;
893
894 c11 = head_a0 * alpha_i[1];
895 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
896
897 c2 = tail_a0 * alpha_i[1];
898 t1 = c11 + c2;
899 t2 = (c2 - (t1 - c11)) + c21;
900
901 head_t2 = t1 + t2;
902 tail_t2 = t2 - (head_t2 - t1);
903 }
904 {
905 /* Compute double-double = double-double + double-double. */
906 double bv;
907 double s1, s2, t1, t2;
908
909 /* Add two hi words. */
910 s1 = head_t1 + head_t2;
911 bv = s1 - head_t1;
912 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
913
914 /* Add two lo words. */
915 t1 = tail_t1 + tail_t2;
916 bv = t1 - tail_t1;
917 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
918
919 s2 += t1;
920
921 /* Renormalize (s1, s2) to (t1, s2) */
922 t1 = s1 + s2;
923 s2 = s2 - (t1 - s1);
924
925 t2 += s2;
926
927 /* Renormalize (t1, t2) */
928 head_t1 = t1 + t2;
929 tail_t1 = t2 - (head_t1 - t1);
930 }
931 head_result[1] = head_t1;
932 tail_result[1] = tail_t1;
933 }
934
935 x_i[x_index2] = head_result[0];
936 x_i[x_index2 + 1] = head_result[1];
937 }
938 } else if ((uplo == blas_upper &&
939 trans == blas_no_trans && order == blas_colmajor) ||
940 (uplo == blas_lower &&
941 trans != blas_no_trans && order == blas_rowmajor)) {
942 tp_start = ((n - 1) * n) / 2;
943 inctp2 = n - 1;
944 x_index2 = x_start;
945 for (matrix_row = 0; matrix_row < n; matrix_row++, inctp2 = n - 1) {
946 x_index = x_start + incx * (n - 1);
947 tp_index = (tp_start + matrix_row) * inctp;
948 col_index = (n - 1) - matrix_row;
949 head_rowsum[0] = head_rowsum[1] = tail_rowsum[0] =
950 tail_rowsum[1] = 0.0;
951 head_rowtmp[0] = head_rowtmp[1] = tail_rowtmp[0] =
952 tail_rowtmp[1] = 0.0;
953 head_result[0] = head_result[1] = tail_result[0] =
954 tail_result[1] = 0.0;
955 while (col_index >= 0) {
956 vecval[0] = x_i[x_index];
957 vecval[1] = x_i[x_index + 1];
958 if ((diag == blas_unit_diag) && (col_index == 0)) {
959 {
960 double cd[2];
961 cd[0] = (double) one[0];
962 cd[1] = (double) one[1];
963 {
964 /* Compute complex-extra = complex-double * complex-double. */
965 double head_t1, tail_t1;
966 double head_t2, tail_t2;
967 /* Real part */
968 {
969 /* Compute double_double = double * double. */
970 double a1, a2, b1, b2, con;
971
972 con = vecval[0] * split;
973 a1 = con - vecval[0];
974 a1 = con - a1;
975 a2 = vecval[0] - a1;
976 con = cd[0] * split;
977 b1 = con - cd[0];
978 b1 = con - b1;
979 b2 = cd[0] - b1;
980
981 head_t1 = vecval[0] * cd[0];
982 tail_t1 =
983 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
984 a2 * b2;
985 }
986 {
987 /* Compute double_double = double * double. */
988 double a1, a2, b1, b2, con;
989
990 con = vecval[1] * split;
991 a1 = con - vecval[1];
992 a1 = con - a1;
993 a2 = vecval[1] - a1;
994 con = cd[1] * split;
995 b1 = con - cd[1];
996 b1 = con - b1;
997 b2 = cd[1] - b1;
998
999 head_t2 = vecval[1] * cd[1];
1000 tail_t2 =
1001 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1002 a2 * b2;
1003 }
1004 head_t2 = -head_t2;
1005 tail_t2 = -tail_t2;
1006 {
1007 /* Compute double-double = double-double + double-double. */
1008 double bv;
1009 double s1, s2, t1, t2;
1010
1011 /* Add two hi words. */
1012 s1 = head_t1 + head_t2;
1013 bv = s1 - head_t1;
1014 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1015
1016 /* Add two lo words. */
1017 t1 = tail_t1 + tail_t2;
1018 bv = t1 - tail_t1;
1019 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1020
1021 s2 += t1;
1022
1023 /* Renormalize (s1, s2) to (t1, s2) */
1024 t1 = s1 + s2;
1025 s2 = s2 - (t1 - s1);
1026
1027 t2 += s2;
1028
1029 /* Renormalize (t1, t2) */
1030 head_t1 = t1 + t2;
1031 tail_t1 = t2 - (head_t1 - t1);
1032 }
1033 head_rowtmp[0] = head_t1;
1034 tail_rowtmp[0] = tail_t1;
1035 /* Imaginary part */
1036 {
1037 /* Compute double_double = double * double. */
1038 double a1, a2, b1, b2, con;
1039
1040 con = vecval[1] * split;
1041 a1 = con - vecval[1];
1042 a1 = con - a1;
1043 a2 = vecval[1] - a1;
1044 con = cd[0] * split;
1045 b1 = con - cd[0];
1046 b1 = con - b1;
1047 b2 = cd[0] - b1;
1048
1049 head_t1 = vecval[1] * cd[0];
1050 tail_t1 =
1051 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1052 a2 * b2;
1053 }
1054 {
1055 /* Compute double_double = double * double. */
1056 double a1, a2, b1, b2, con;
1057
1058 con = vecval[0] * split;
1059 a1 = con - vecval[0];
1060 a1 = con - a1;
1061 a2 = vecval[0] - a1;
1062 con = cd[1] * split;
1063 b1 = con - cd[1];
1064 b1 = con - b1;
1065 b2 = cd[1] - b1;
1066
1067 head_t2 = vecval[0] * cd[1];
1068 tail_t2 =
1069 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1070 a2 * b2;
1071 }
1072 {
1073 /* Compute double-double = double-double + double-double. */
1074 double bv;
1075 double s1, s2, t1, t2;
1076
1077 /* Add two hi words. */
1078 s1 = head_t1 + head_t2;
1079 bv = s1 - head_t1;
1080 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1081
1082 /* Add two lo words. */
1083 t1 = tail_t1 + tail_t2;
1084 bv = t1 - tail_t1;
1085 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1086
1087 s2 += t1;
1088
1089 /* Renormalize (s1, s2) to (t1, s2) */
1090 t1 = s1 + s2;
1091 s2 = s2 - (t1 - s1);
1092
1093 t2 += s2;
1094
1095 /* Renormalize (t1, t2) */
1096 head_t1 = t1 + t2;
1097 tail_t1 = t2 - (head_t1 - t1);
1098 }
1099 head_rowtmp[1] = head_t1;
1100 tail_rowtmp[1] = tail_t1;
1101 }
1102 }
1103 } else {
1104 matval[0] = tp_i[tp_index];
1105 matval[1] = tp_i[tp_index + 1];
1106 {
1107 double cd[2];
1108 cd[0] = (double) matval[0];
1109 cd[1] = (double) matval[1];
1110 {
1111 /* Compute complex-extra = complex-double * complex-double. */
1112 double head_t1, tail_t1;
1113 double head_t2, tail_t2;
1114 /* Real part */
1115 {
1116 /* Compute double_double = double * double. */
1117 double a1, a2, b1, b2, con;
1118
1119 con = vecval[0] * split;
1120 a1 = con - vecval[0];
1121 a1 = con - a1;
1122 a2 = vecval[0] - a1;
1123 con = cd[0] * split;
1124 b1 = con - cd[0];
1125 b1 = con - b1;
1126 b2 = cd[0] - b1;
1127
1128 head_t1 = vecval[0] * cd[0];
1129 tail_t1 =
1130 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1131 a2 * b2;
1132 }
1133 {
1134 /* Compute double_double = double * double. */
1135 double a1, a2, b1, b2, con;
1136
1137 con = vecval[1] * split;
1138 a1 = con - vecval[1];
1139 a1 = con - a1;
1140 a2 = vecval[1] - a1;
1141 con = cd[1] * split;
1142 b1 = con - cd[1];
1143 b1 = con - b1;
1144 b2 = cd[1] - b1;
1145
1146 head_t2 = vecval[1] * cd[1];
1147 tail_t2 =
1148 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1149 a2 * b2;
1150 }
1151 head_t2 = -head_t2;
1152 tail_t2 = -tail_t2;
1153 {
1154 /* Compute double-double = double-double + double-double. */
1155 double bv;
1156 double s1, s2, t1, t2;
1157
1158 /* Add two hi words. */
1159 s1 = head_t1 + head_t2;
1160 bv = s1 - head_t1;
1161 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1162
1163 /* Add two lo words. */
1164 t1 = tail_t1 + tail_t2;
1165 bv = t1 - tail_t1;
1166 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1167
1168 s2 += t1;
1169
1170 /* Renormalize (s1, s2) to (t1, s2) */
1171 t1 = s1 + s2;
1172 s2 = s2 - (t1 - s1);
1173
1174 t2 += s2;
1175
1176 /* Renormalize (t1, t2) */
1177 head_t1 = t1 + t2;
1178 tail_t1 = t2 - (head_t1 - t1);
1179 }
1180 head_rowtmp[0] = head_t1;
1181 tail_rowtmp[0] = tail_t1;
1182 /* Imaginary part */
1183 {
1184 /* Compute double_double = double * double. */
1185 double a1, a2, b1, b2, con;
1186
1187 con = vecval[1] * split;
1188 a1 = con - vecval[1];
1189 a1 = con - a1;
1190 a2 = vecval[1] - a1;
1191 con = cd[0] * split;
1192 b1 = con - cd[0];
1193 b1 = con - b1;
1194 b2 = cd[0] - b1;
1195
1196 head_t1 = vecval[1] * cd[0];
1197 tail_t1 =
1198 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1199 a2 * b2;
1200 }
1201 {
1202 /* Compute double_double = double * double. */
1203 double a1, a2, b1, b2, con;
1204
1205 con = vecval[0] * split;
1206 a1 = con - vecval[0];
1207 a1 = con - a1;
1208 a2 = vecval[0] - a1;
1209 con = cd[1] * split;
1210 b1 = con - cd[1];
1211 b1 = con - b1;
1212 b2 = cd[1] - b1;
1213
1214 head_t2 = vecval[0] * cd[1];
1215 tail_t2 =
1216 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1217 a2 * b2;
1218 }
1219 {
1220 /* Compute double-double = double-double + double-double. */
1221 double bv;
1222 double s1, s2, t1, t2;
1223
1224 /* Add two hi words. */
1225 s1 = head_t1 + head_t2;
1226 bv = s1 - head_t1;
1227 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1228
1229 /* Add two lo words. */
1230 t1 = tail_t1 + tail_t2;
1231 bv = t1 - tail_t1;
1232 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1233
1234 s2 += t1;
1235
1236 /* Renormalize (s1, s2) to (t1, s2) */
1237 t1 = s1 + s2;
1238 s2 = s2 - (t1 - s1);
1239
1240 t2 += s2;
1241
1242 /* Renormalize (t1, t2) */
1243 head_t1 = t1 + t2;
1244 tail_t1 = t2 - (head_t1 - t1);
1245 }
1246 head_rowtmp[1] = head_t1;
1247 tail_rowtmp[1] = tail_t1;
1248 }
1249 }
1250 }
1251 {
1252 double head_t, tail_t;
1253 double head_a, tail_a;
1254 double head_b, tail_b;
1255 /* Real part */
1256 head_a = head_rowsum[0];
1257 tail_a = tail_rowsum[0];
1258 head_b = head_rowtmp[0];
1259 tail_b = tail_rowtmp[0];
1260 {
1261 /* Compute double-double = double-double + double-double. */
1262 double bv;
1263 double s1, s2, t1, t2;
1264
1265 /* Add two hi words. */
1266 s1 = head_a + head_b;
1267 bv = s1 - head_a;
1268 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
1269
1270 /* Add two lo words. */
1271 t1 = tail_a + tail_b;
1272 bv = t1 - tail_a;
1273 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
1274
1275 s2 += t1;
1276
1277 /* Renormalize (s1, s2) to (t1, s2) */
1278 t1 = s1 + s2;
1279 s2 = s2 - (t1 - s1);
1280
1281 t2 += s2;
1282
1283 /* Renormalize (t1, t2) */
1284 head_t = t1 + t2;
1285 tail_t = t2 - (head_t - t1);
1286 }
1287 head_rowsum[0] = head_t;
1288 tail_rowsum[0] = tail_t;
1289 /* Imaginary part */
1290 head_a = head_rowsum[1];
1291 tail_a = tail_rowsum[1];
1292 head_b = head_rowtmp[1];
1293 tail_b = tail_rowtmp[1];
1294 {
1295 /* Compute double-double = double-double + double-double. */
1296 double bv;
1297 double s1, s2, t1, t2;
1298
1299 /* Add two hi words. */
1300 s1 = head_a + head_b;
1301 bv = s1 - head_a;
1302 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
1303
1304 /* Add two lo words. */
1305 t1 = tail_a + tail_b;
1306 bv = t1 - tail_a;
1307 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
1308
1309 s2 += t1;
1310
1311 /* Renormalize (s1, s2) to (t1, s2) */
1312 t1 = s1 + s2;
1313 s2 = s2 - (t1 - s1);
1314
1315 t2 += s2;
1316
1317 /* Renormalize (t1, t2) */
1318 head_t = t1 + t2;
1319 tail_t = t2 - (head_t - t1);
1320 }
1321 head_rowsum[1] = head_t;
1322 tail_rowsum[1] = tail_t;
1323 }
1324 x_index -= incx;
1325 tp_index -= inctp2 * inctp;
1326 inctp2--;
1327 col_index--;
1328 }
1329 {
1330 /* Compute complex-extra = complex-extra * complex-double. */
1331 double head_a0, tail_a0;
1332 double head_a1, tail_a1;
1333 double head_t1, tail_t1;
1334 double head_t2, tail_t2;
1335 head_a0 = head_rowsum[0];
1336 tail_a0 = tail_rowsum[0];
1337 head_a1 = head_rowsum[1];
1338 tail_a1 = tail_rowsum[1];
1339 /* real part */
1340 {
1341 /* Compute double-double = double-double * double. */
1342 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1343
1344 con = head_a0 * split;
1345 a11 = con - head_a0;
1346 a11 = con - a11;
1347 a21 = head_a0 - a11;
1348 con = alpha_i[0] * split;
1349 b1 = con - alpha_i[0];
1350 b1 = con - b1;
1351 b2 = alpha_i[0] - b1;
1352
1353 c11 = head_a0 * alpha_i[0];
1354 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1355
1356 c2 = tail_a0 * alpha_i[0];
1357 t1 = c11 + c2;
1358 t2 = (c2 - (t1 - c11)) + c21;
1359
1360 head_t1 = t1 + t2;
1361 tail_t1 = t2 - (head_t1 - t1);
1362 }
1363 {
1364 /* Compute double-double = double-double * double. */
1365 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1366
1367 con = head_a1 * split;
1368 a11 = con - head_a1;
1369 a11 = con - a11;
1370 a21 = head_a1 - a11;
1371 con = alpha_i[1] * split;
1372 b1 = con - alpha_i[1];
1373 b1 = con - b1;
1374 b2 = alpha_i[1] - b1;
1375
1376 c11 = head_a1 * alpha_i[1];
1377 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1378
1379 c2 = tail_a1 * alpha_i[1];
1380 t1 = c11 + c2;
1381 t2 = (c2 - (t1 - c11)) + c21;
1382
1383 head_t2 = t1 + t2;
1384 tail_t2 = t2 - (head_t2 - t1);
1385 }
1386 head_t2 = -head_t2;
1387 tail_t2 = -tail_t2;
1388 {
1389 /* Compute double-double = double-double + double-double. */
1390 double bv;
1391 double s1, s2, t1, t2;
1392
1393 /* Add two hi words. */
1394 s1 = head_t1 + head_t2;
1395 bv = s1 - head_t1;
1396 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1397
1398 /* Add two lo words. */
1399 t1 = tail_t1 + tail_t2;
1400 bv = t1 - tail_t1;
1401 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1402
1403 s2 += t1;
1404
1405 /* Renormalize (s1, s2) to (t1, s2) */
1406 t1 = s1 + s2;
1407 s2 = s2 - (t1 - s1);
1408
1409 t2 += s2;
1410
1411 /* Renormalize (t1, t2) */
1412 head_t1 = t1 + t2;
1413 tail_t1 = t2 - (head_t1 - t1);
1414 }
1415 head_result[0] = head_t1;
1416 tail_result[0] = tail_t1;
1417 /* imaginary part */
1418 {
1419 /* Compute double-double = double-double * double. */
1420 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1421
1422 con = head_a1 * split;
1423 a11 = con - head_a1;
1424 a11 = con - a11;
1425 a21 = head_a1 - a11;
1426 con = alpha_i[0] * split;
1427 b1 = con - alpha_i[0];
1428 b1 = con - b1;
1429 b2 = alpha_i[0] - b1;
1430
1431 c11 = head_a1 * alpha_i[0];
1432 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1433
1434 c2 = tail_a1 * alpha_i[0];
1435 t1 = c11 + c2;
1436 t2 = (c2 - (t1 - c11)) + c21;
1437
1438 head_t1 = t1 + t2;
1439 tail_t1 = t2 - (head_t1 - t1);
1440 }
1441 {
1442 /* Compute double-double = double-double * double. */
1443 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1444
1445 con = head_a0 * split;
1446 a11 = con - head_a0;
1447 a11 = con - a11;
1448 a21 = head_a0 - a11;
1449 con = alpha_i[1] * split;
1450 b1 = con - alpha_i[1];
1451 b1 = con - b1;
1452 b2 = alpha_i[1] - b1;
1453
1454 c11 = head_a0 * alpha_i[1];
1455 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1456
1457 c2 = tail_a0 * alpha_i[1];
1458 t1 = c11 + c2;
1459 t2 = (c2 - (t1 - c11)) + c21;
1460
1461 head_t2 = t1 + t2;
1462 tail_t2 = t2 - (head_t2 - t1);
1463 }
1464 {
1465 /* Compute double-double = double-double + double-double. */
1466 double bv;
1467 double s1, s2, t1, t2;
1468
1469 /* Add two hi words. */
1470 s1 = head_t1 + head_t2;
1471 bv = s1 - head_t1;
1472 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1473
1474 /* Add two lo words. */
1475 t1 = tail_t1 + tail_t2;
1476 bv = t1 - tail_t1;
1477 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1478
1479 s2 += t1;
1480
1481 /* Renormalize (s1, s2) to (t1, s2) */
1482 t1 = s1 + s2;
1483 s2 = s2 - (t1 - s1);
1484
1485 t2 += s2;
1486
1487 /* Renormalize (t1, t2) */
1488 head_t1 = t1 + t2;
1489 tail_t1 = t2 - (head_t1 - t1);
1490 }
1491 head_result[1] = head_t1;
1492 tail_result[1] = tail_t1;
1493 }
1494
1495 x_i[x_index2] = head_result[0];
1496 x_i[x_index2 + 1] = head_result[1];
1497 x_index2 += incx;
1498 }
1499 } else if ((uplo == blas_lower &&
1500 trans == blas_no_trans && order == blas_rowmajor) ||
1501 (uplo == blas_upper &&
1502 trans != blas_no_trans && order == blas_colmajor)) {
1503 tp_start = (n - 1) + ((n - 1) * n) / 2;
1504 tp_index = tp_start * inctp;
1505 x_index = x_start + (n - 1) * incx;
1506
1507 for (matrix_row = n - 1; matrix_row >= 0; matrix_row--) {
1508 x_index2 = x_index;
1509 head_rowsum[0] = head_rowsum[1] = tail_rowsum[0] =
1510 tail_rowsum[1] = 0.0;
1511 head_rowtmp[0] = head_rowtmp[1] = tail_rowtmp[0] =
1512 tail_rowtmp[1] = 0.0;
1513 head_result[0] = head_result[1] = tail_result[0] =
1514 tail_result[1] = 0.0;
1515 for (step = 0; step <= matrix_row; step++) {
1516 vecval[0] = x_i[x_index2];
1517 vecval[1] = x_i[x_index2 + 1];
1518 if ((diag == blas_unit_diag) && (step == 0)) {
1519 {
1520 double cd[2];
1521 cd[0] = (double) one[0];
1522 cd[1] = (double) one[1];
1523 {
1524 /* Compute complex-extra = complex-double * complex-double. */
1525 double head_t1, tail_t1;
1526 double head_t2, tail_t2;
1527 /* Real part */
1528 {
1529 /* Compute double_double = double * double. */
1530 double a1, a2, b1, b2, con;
1531
1532 con = vecval[0] * split;
1533 a1 = con - vecval[0];
1534 a1 = con - a1;
1535 a2 = vecval[0] - a1;
1536 con = cd[0] * split;
1537 b1 = con - cd[0];
1538 b1 = con - b1;
1539 b2 = cd[0] - b1;
1540
1541 head_t1 = vecval[0] * cd[0];
1542 tail_t1 =
1543 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1544 a2 * b2;
1545 }
1546 {
1547 /* Compute double_double = double * double. */
1548 double a1, a2, b1, b2, con;
1549
1550 con = vecval[1] * split;
1551 a1 = con - vecval[1];
1552 a1 = con - a1;
1553 a2 = vecval[1] - a1;
1554 con = cd[1] * split;
1555 b1 = con - cd[1];
1556 b1 = con - b1;
1557 b2 = cd[1] - b1;
1558
1559 head_t2 = vecval[1] * cd[1];
1560 tail_t2 =
1561 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1562 a2 * b2;
1563 }
1564 head_t2 = -head_t2;
1565 tail_t2 = -tail_t2;
1566 {
1567 /* Compute double-double = double-double + double-double. */
1568 double bv;
1569 double s1, s2, t1, t2;
1570
1571 /* Add two hi words. */
1572 s1 = head_t1 + head_t2;
1573 bv = s1 - head_t1;
1574 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1575
1576 /* Add two lo words. */
1577 t1 = tail_t1 + tail_t2;
1578 bv = t1 - tail_t1;
1579 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1580
1581 s2 += t1;
1582
1583 /* Renormalize (s1, s2) to (t1, s2) */
1584 t1 = s1 + s2;
1585 s2 = s2 - (t1 - s1);
1586
1587 t2 += s2;
1588
1589 /* Renormalize (t1, t2) */
1590 head_t1 = t1 + t2;
1591 tail_t1 = t2 - (head_t1 - t1);
1592 }
1593 head_rowtmp[0] = head_t1;
1594 tail_rowtmp[0] = tail_t1;
1595 /* Imaginary part */
1596 {
1597 /* Compute double_double = double * double. */
1598 double a1, a2, b1, b2, con;
1599
1600 con = vecval[1] * split;
1601 a1 = con - vecval[1];
1602 a1 = con - a1;
1603 a2 = vecval[1] - a1;
1604 con = cd[0] * split;
1605 b1 = con - cd[0];
1606 b1 = con - b1;
1607 b2 = cd[0] - b1;
1608
1609 head_t1 = vecval[1] * cd[0];
1610 tail_t1 =
1611 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1612 a2 * b2;
1613 }
1614 {
1615 /* Compute double_double = double * double. */
1616 double a1, a2, b1, b2, con;
1617
1618 con = vecval[0] * split;
1619 a1 = con - vecval[0];
1620 a1 = con - a1;
1621 a2 = vecval[0] - a1;
1622 con = cd[1] * split;
1623 b1 = con - cd[1];
1624 b1 = con - b1;
1625 b2 = cd[1] - b1;
1626
1627 head_t2 = vecval[0] * cd[1];
1628 tail_t2 =
1629 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1630 a2 * b2;
1631 }
1632 {
1633 /* Compute double-double = double-double + double-double. */
1634 double bv;
1635 double s1, s2, t1, t2;
1636
1637 /* Add two hi words. */
1638 s1 = head_t1 + head_t2;
1639 bv = s1 - head_t1;
1640 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1641
1642 /* Add two lo words. */
1643 t1 = tail_t1 + tail_t2;
1644 bv = t1 - tail_t1;
1645 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1646
1647 s2 += t1;
1648
1649 /* Renormalize (s1, s2) to (t1, s2) */
1650 t1 = s1 + s2;
1651 s2 = s2 - (t1 - s1);
1652
1653 t2 += s2;
1654
1655 /* Renormalize (t1, t2) */
1656 head_t1 = t1 + t2;
1657 tail_t1 = t2 - (head_t1 - t1);
1658 }
1659 head_rowtmp[1] = head_t1;
1660 tail_rowtmp[1] = tail_t1;
1661 }
1662 }
1663 } else {
1664 matval[0] = tp_i[tp_index];
1665 matval[1] = tp_i[tp_index + 1];
1666 {
1667 double cd[2];
1668 cd[0] = (double) matval[0];
1669 cd[1] = (double) matval[1];
1670 {
1671 /* Compute complex-extra = complex-double * complex-double. */
1672 double head_t1, tail_t1;
1673 double head_t2, tail_t2;
1674 /* Real part */
1675 {
1676 /* Compute double_double = double * double. */
1677 double a1, a2, b1, b2, con;
1678
1679 con = vecval[0] * split;
1680 a1 = con - vecval[0];
1681 a1 = con - a1;
1682 a2 = vecval[0] - a1;
1683 con = cd[0] * split;
1684 b1 = con - cd[0];
1685 b1 = con - b1;
1686 b2 = cd[0] - b1;
1687
1688 head_t1 = vecval[0] * cd[0];
1689 tail_t1 =
1690 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1691 a2 * b2;
1692 }
1693 {
1694 /* Compute double_double = double * double. */
1695 double a1, a2, b1, b2, con;
1696
1697 con = vecval[1] * split;
1698 a1 = con - vecval[1];
1699 a1 = con - a1;
1700 a2 = vecval[1] - a1;
1701 con = cd[1] * split;
1702 b1 = con - cd[1];
1703 b1 = con - b1;
1704 b2 = cd[1] - b1;
1705
1706 head_t2 = vecval[1] * cd[1];
1707 tail_t2 =
1708 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1709 a2 * b2;
1710 }
1711 head_t2 = -head_t2;
1712 tail_t2 = -tail_t2;
1713 {
1714 /* Compute double-double = double-double + double-double. */
1715 double bv;
1716 double s1, s2, t1, t2;
1717
1718 /* Add two hi words. */
1719 s1 = head_t1 + head_t2;
1720 bv = s1 - head_t1;
1721 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1722
1723 /* Add two lo words. */
1724 t1 = tail_t1 + tail_t2;
1725 bv = t1 - tail_t1;
1726 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1727
1728 s2 += t1;
1729
1730 /* Renormalize (s1, s2) to (t1, s2) */
1731 t1 = s1 + s2;
1732 s2 = s2 - (t1 - s1);
1733
1734 t2 += s2;
1735
1736 /* Renormalize (t1, t2) */
1737 head_t1 = t1 + t2;
1738 tail_t1 = t2 - (head_t1 - t1);
1739 }
1740 head_rowtmp[0] = head_t1;
1741 tail_rowtmp[0] = tail_t1;
1742 /* Imaginary part */
1743 {
1744 /* Compute double_double = double * double. */
1745 double a1, a2, b1, b2, con;
1746
1747 con = vecval[1] * split;
1748 a1 = con - vecval[1];
1749 a1 = con - a1;
1750 a2 = vecval[1] - a1;
1751 con = cd[0] * split;
1752 b1 = con - cd[0];
1753 b1 = con - b1;
1754 b2 = cd[0] - b1;
1755
1756 head_t1 = vecval[1] * cd[0];
1757 tail_t1 =
1758 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
1759 a2 * b2;
1760 }
1761 {
1762 /* Compute double_double = double * double. */
1763 double a1, a2, b1, b2, con;
1764
1765 con = vecval[0] * split;
1766 a1 = con - vecval[0];
1767 a1 = con - a1;
1768 a2 = vecval[0] - a1;
1769 con = cd[1] * split;
1770 b1 = con - cd[1];
1771 b1 = con - b1;
1772 b2 = cd[1] - b1;
1773
1774 head_t2 = vecval[0] * cd[1];
1775 tail_t2 =
1776 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
1777 a2 * b2;
1778 }
1779 {
1780 /* Compute double-double = double-double + double-double. */
1781 double bv;
1782 double s1, s2, t1, t2;
1783
1784 /* Add two hi words. */
1785 s1 = head_t1 + head_t2;
1786 bv = s1 - head_t1;
1787 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1788
1789 /* Add two lo words. */
1790 t1 = tail_t1 + tail_t2;
1791 bv = t1 - tail_t1;
1792 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1793
1794 s2 += t1;
1795
1796 /* Renormalize (s1, s2) to (t1, s2) */
1797 t1 = s1 + s2;
1798 s2 = s2 - (t1 - s1);
1799
1800 t2 += s2;
1801
1802 /* Renormalize (t1, t2) */
1803 head_t1 = t1 + t2;
1804 tail_t1 = t2 - (head_t1 - t1);
1805 }
1806 head_rowtmp[1] = head_t1;
1807 tail_rowtmp[1] = tail_t1;
1808 }
1809 }
1810 }
1811 {
1812 double head_t, tail_t;
1813 double head_a, tail_a;
1814 double head_b, tail_b;
1815 /* Real part */
1816 head_a = head_rowsum[0];
1817 tail_a = tail_rowsum[0];
1818 head_b = head_rowtmp[0];
1819 tail_b = tail_rowtmp[0];
1820 {
1821 /* Compute double-double = double-double + double-double. */
1822 double bv;
1823 double s1, s2, t1, t2;
1824
1825 /* Add two hi words. */
1826 s1 = head_a + head_b;
1827 bv = s1 - head_a;
1828 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
1829
1830 /* Add two lo words. */
1831 t1 = tail_a + tail_b;
1832 bv = t1 - tail_a;
1833 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
1834
1835 s2 += t1;
1836
1837 /* Renormalize (s1, s2) to (t1, s2) */
1838 t1 = s1 + s2;
1839 s2 = s2 - (t1 - s1);
1840
1841 t2 += s2;
1842
1843 /* Renormalize (t1, t2) */
1844 head_t = t1 + t2;
1845 tail_t = t2 - (head_t - t1);
1846 }
1847 head_rowsum[0] = head_t;
1848 tail_rowsum[0] = tail_t;
1849 /* Imaginary part */
1850 head_a = head_rowsum[1];
1851 tail_a = tail_rowsum[1];
1852 head_b = head_rowtmp[1];
1853 tail_b = tail_rowtmp[1];
1854 {
1855 /* Compute double-double = double-double + double-double. */
1856 double bv;
1857 double s1, s2, t1, t2;
1858
1859 /* Add two hi words. */
1860 s1 = head_a + head_b;
1861 bv = s1 - head_a;
1862 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
1863
1864 /* Add two lo words. */
1865 t1 = tail_a + tail_b;
1866 bv = t1 - tail_a;
1867 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
1868
1869 s2 += t1;
1870
1871 /* Renormalize (s1, s2) to (t1, s2) */
1872 t1 = s1 + s2;
1873 s2 = s2 - (t1 - s1);
1874
1875 t2 += s2;
1876
1877 /* Renormalize (t1, t2) */
1878 head_t = t1 + t2;
1879 tail_t = t2 - (head_t - t1);
1880 }
1881 head_rowsum[1] = head_t;
1882 tail_rowsum[1] = tail_t;
1883 }
1884 x_index2 -= incx;
1885 tp_index -= inctp;
1886 }
1887 {
1888 /* Compute complex-extra = complex-extra * complex-double. */
1889 double head_a0, tail_a0;
1890 double head_a1, tail_a1;
1891 double head_t1, tail_t1;
1892 double head_t2, tail_t2;
1893 head_a0 = head_rowsum[0];
1894 tail_a0 = tail_rowsum[0];
1895 head_a1 = head_rowsum[1];
1896 tail_a1 = tail_rowsum[1];
1897 /* real part */
1898 {
1899 /* Compute double-double = double-double * double. */
1900 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1901
1902 con = head_a0 * split;
1903 a11 = con - head_a0;
1904 a11 = con - a11;
1905 a21 = head_a0 - a11;
1906 con = alpha_i[0] * split;
1907 b1 = con - alpha_i[0];
1908 b1 = con - b1;
1909 b2 = alpha_i[0] - b1;
1910
1911 c11 = head_a0 * alpha_i[0];
1912 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1913
1914 c2 = tail_a0 * alpha_i[0];
1915 t1 = c11 + c2;
1916 t2 = (c2 - (t1 - c11)) + c21;
1917
1918 head_t1 = t1 + t2;
1919 tail_t1 = t2 - (head_t1 - t1);
1920 }
1921 {
1922 /* Compute double-double = double-double * double. */
1923 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1924
1925 con = head_a1 * split;
1926 a11 = con - head_a1;
1927 a11 = con - a11;
1928 a21 = head_a1 - a11;
1929 con = alpha_i[1] * split;
1930 b1 = con - alpha_i[1];
1931 b1 = con - b1;
1932 b2 = alpha_i[1] - b1;
1933
1934 c11 = head_a1 * alpha_i[1];
1935 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1936
1937 c2 = tail_a1 * alpha_i[1];
1938 t1 = c11 + c2;
1939 t2 = (c2 - (t1 - c11)) + c21;
1940
1941 head_t2 = t1 + t2;
1942 tail_t2 = t2 - (head_t2 - t1);
1943 }
1944 head_t2 = -head_t2;
1945 tail_t2 = -tail_t2;
1946 {
1947 /* Compute double-double = double-double + double-double. */
1948 double bv;
1949 double s1, s2, t1, t2;
1950
1951 /* Add two hi words. */
1952 s1 = head_t1 + head_t2;
1953 bv = s1 - head_t1;
1954 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
1955
1956 /* Add two lo words. */
1957 t1 = tail_t1 + tail_t2;
1958 bv = t1 - tail_t1;
1959 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
1960
1961 s2 += t1;
1962
1963 /* Renormalize (s1, s2) to (t1, s2) */
1964 t1 = s1 + s2;
1965 s2 = s2 - (t1 - s1);
1966
1967 t2 += s2;
1968
1969 /* Renormalize (t1, t2) */
1970 head_t1 = t1 + t2;
1971 tail_t1 = t2 - (head_t1 - t1);
1972 }
1973 head_result[0] = head_t1;
1974 tail_result[0] = tail_t1;
1975 /* imaginary part */
1976 {
1977 /* Compute double-double = double-double * double. */
1978 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
1979
1980 con = head_a1 * split;
1981 a11 = con - head_a1;
1982 a11 = con - a11;
1983 a21 = head_a1 - a11;
1984 con = alpha_i[0] * split;
1985 b1 = con - alpha_i[0];
1986 b1 = con - b1;
1987 b2 = alpha_i[0] - b1;
1988
1989 c11 = head_a1 * alpha_i[0];
1990 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
1991
1992 c2 = tail_a1 * alpha_i[0];
1993 t1 = c11 + c2;
1994 t2 = (c2 - (t1 - c11)) + c21;
1995
1996 head_t1 = t1 + t2;
1997 tail_t1 = t2 - (head_t1 - t1);
1998 }
1999 {
2000 /* Compute double-double = double-double * double. */
2001 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
2002
2003 con = head_a0 * split;
2004 a11 = con - head_a0;
2005 a11 = con - a11;
2006 a21 = head_a0 - a11;
2007 con = alpha_i[1] * split;
2008 b1 = con - alpha_i[1];
2009 b1 = con - b1;
2010 b2 = alpha_i[1] - b1;
2011
2012 c11 = head_a0 * alpha_i[1];
2013 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
2014
2015 c2 = tail_a0 * alpha_i[1];
2016 t1 = c11 + c2;
2017 t2 = (c2 - (t1 - c11)) + c21;
2018
2019 head_t2 = t1 + t2;
2020 tail_t2 = t2 - (head_t2 - t1);
2021 }
2022 {
2023 /* Compute double-double = double-double + double-double. */
2024 double bv;
2025 double s1, s2, t1, t2;
2026
2027 /* Add two hi words. */
2028 s1 = head_t1 + head_t2;
2029 bv = s1 - head_t1;
2030 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2031
2032 /* Add two lo words. */
2033 t1 = tail_t1 + tail_t2;
2034 bv = t1 - tail_t1;
2035 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2036
2037 s2 += t1;
2038
2039 /* Renormalize (s1, s2) to (t1, s2) */
2040 t1 = s1 + s2;
2041 s2 = s2 - (t1 - s1);
2042
2043 t2 += s2;
2044
2045 /* Renormalize (t1, t2) */
2046 head_t1 = t1 + t2;
2047 tail_t1 = t2 - (head_t1 - t1);
2048 }
2049 head_result[1] = head_t1;
2050 tail_result[1] = tail_t1;
2051 }
2052
2053 x_i[x_index] = head_result[0];
2054 x_i[x_index + 1] = head_result[1];
2055 x_index -= incx;
2056 }
2057 } else {
2058 tp_start = 0;
2059 x_index = x_start + (n - 1) * incx;
2060 for (matrix_row = n - 1; matrix_row >= 0; matrix_row--) {
2061 tp_index = matrix_row * inctp;
2062 x_index2 = x_start;
2063 head_rowsum[0] = head_rowsum[1] = tail_rowsum[0] =
2064 tail_rowsum[1] = 0.0;
2065 head_rowtmp[0] = head_rowtmp[1] = tail_rowtmp[0] =
2066 tail_rowtmp[1] = 0.0;
2067 head_result[0] = head_result[1] = tail_result[0] =
2068 tail_result[1] = 0.0;
2069 stride = n;
2070 for (step = 0; step <= matrix_row; step++) {
2071 vecval[0] = x_i[x_index2];
2072 vecval[1] = x_i[x_index2 + 1];
2073 if ((diag == blas_unit_diag) && (step == matrix_row)) {
2074 {
2075 double cd[2];
2076 cd[0] = (double) one[0];
2077 cd[1] = (double) one[1];
2078 {
2079 /* Compute complex-extra = complex-double * complex-double. */
2080 double head_t1, tail_t1;
2081 double head_t2, tail_t2;
2082 /* Real part */
2083 {
2084 /* Compute double_double = double * double. */
2085 double a1, a2, b1, b2, con;
2086
2087 con = vecval[0] * split;
2088 a1 = con - vecval[0];
2089 a1 = con - a1;
2090 a2 = vecval[0] - a1;
2091 con = cd[0] * split;
2092 b1 = con - cd[0];
2093 b1 = con - b1;
2094 b2 = cd[0] - b1;
2095
2096 head_t1 = vecval[0] * cd[0];
2097 tail_t1 =
2098 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
2099 a2 * b2;
2100 }
2101 {
2102 /* Compute double_double = double * double. */
2103 double a1, a2, b1, b2, con;
2104
2105 con = vecval[1] * split;
2106 a1 = con - vecval[1];
2107 a1 = con - a1;
2108 a2 = vecval[1] - a1;
2109 con = cd[1] * split;
2110 b1 = con - cd[1];
2111 b1 = con - b1;
2112 b2 = cd[1] - b1;
2113
2114 head_t2 = vecval[1] * cd[1];
2115 tail_t2 =
2116 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
2117 a2 * b2;
2118 }
2119 head_t2 = -head_t2;
2120 tail_t2 = -tail_t2;
2121 {
2122 /* Compute double-double = double-double + double-double. */
2123 double bv;
2124 double s1, s2, t1, t2;
2125
2126 /* Add two hi words. */
2127 s1 = head_t1 + head_t2;
2128 bv = s1 - head_t1;
2129 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2130
2131 /* Add two lo words. */
2132 t1 = tail_t1 + tail_t2;
2133 bv = t1 - tail_t1;
2134 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2135
2136 s2 += t1;
2137
2138 /* Renormalize (s1, s2) to (t1, s2) */
2139 t1 = s1 + s2;
2140 s2 = s2 - (t1 - s1);
2141
2142 t2 += s2;
2143
2144 /* Renormalize (t1, t2) */
2145 head_t1 = t1 + t2;
2146 tail_t1 = t2 - (head_t1 - t1);
2147 }
2148 head_rowtmp[0] = head_t1;
2149 tail_rowtmp[0] = tail_t1;
2150 /* Imaginary part */
2151 {
2152 /* Compute double_double = double * double. */
2153 double a1, a2, b1, b2, con;
2154
2155 con = vecval[1] * split;
2156 a1 = con - vecval[1];
2157 a1 = con - a1;
2158 a2 = vecval[1] - a1;
2159 con = cd[0] * split;
2160 b1 = con - cd[0];
2161 b1 = con - b1;
2162 b2 = cd[0] - b1;
2163
2164 head_t1 = vecval[1] * cd[0];
2165 tail_t1 =
2166 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
2167 a2 * b2;
2168 }
2169 {
2170 /* Compute double_double = double * double. */
2171 double a1, a2, b1, b2, con;
2172
2173 con = vecval[0] * split;
2174 a1 = con - vecval[0];
2175 a1 = con - a1;
2176 a2 = vecval[0] - a1;
2177 con = cd[1] * split;
2178 b1 = con - cd[1];
2179 b1 = con - b1;
2180 b2 = cd[1] - b1;
2181
2182 head_t2 = vecval[0] * cd[1];
2183 tail_t2 =
2184 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
2185 a2 * b2;
2186 }
2187 {
2188 /* Compute double-double = double-double + double-double. */
2189 double bv;
2190 double s1, s2, t1, t2;
2191
2192 /* Add two hi words. */
2193 s1 = head_t1 + head_t2;
2194 bv = s1 - head_t1;
2195 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2196
2197 /* Add two lo words. */
2198 t1 = tail_t1 + tail_t2;
2199 bv = t1 - tail_t1;
2200 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2201
2202 s2 += t1;
2203
2204 /* Renormalize (s1, s2) to (t1, s2) */
2205 t1 = s1 + s2;
2206 s2 = s2 - (t1 - s1);
2207
2208 t2 += s2;
2209
2210 /* Renormalize (t1, t2) */
2211 head_t1 = t1 + t2;
2212 tail_t1 = t2 - (head_t1 - t1);
2213 }
2214 head_rowtmp[1] = head_t1;
2215 tail_rowtmp[1] = tail_t1;
2216 }
2217 }
2218 } else {
2219 matval[0] = tp_i[tp_index];
2220 matval[1] = tp_i[tp_index + 1];
2221 {
2222 double cd[2];
2223 cd[0] = (double) matval[0];
2224 cd[1] = (double) matval[1];
2225 {
2226 /* Compute complex-extra = complex-double * complex-double. */
2227 double head_t1, tail_t1;
2228 double head_t2, tail_t2;
2229 /* Real part */
2230 {
2231 /* Compute double_double = double * double. */
2232 double a1, a2, b1, b2, con;
2233
2234 con = vecval[0] * split;
2235 a1 = con - vecval[0];
2236 a1 = con - a1;
2237 a2 = vecval[0] - a1;
2238 con = cd[0] * split;
2239 b1 = con - cd[0];
2240 b1 = con - b1;
2241 b2 = cd[0] - b1;
2242
2243 head_t1 = vecval[0] * cd[0];
2244 tail_t1 =
2245 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
2246 a2 * b2;
2247 }
2248 {
2249 /* Compute double_double = double * double. */
2250 double a1, a2, b1, b2, con;
2251
2252 con = vecval[1] * split;
2253 a1 = con - vecval[1];
2254 a1 = con - a1;
2255 a2 = vecval[1] - a1;
2256 con = cd[1] * split;
2257 b1 = con - cd[1];
2258 b1 = con - b1;
2259 b2 = cd[1] - b1;
2260
2261 head_t2 = vecval[1] * cd[1];
2262 tail_t2 =
2263 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
2264 a2 * b2;
2265 }
2266 head_t2 = -head_t2;
2267 tail_t2 = -tail_t2;
2268 {
2269 /* Compute double-double = double-double + double-double. */
2270 double bv;
2271 double s1, s2, t1, t2;
2272
2273 /* Add two hi words. */
2274 s1 = head_t1 + head_t2;
2275 bv = s1 - head_t1;
2276 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2277
2278 /* Add two lo words. */
2279 t1 = tail_t1 + tail_t2;
2280 bv = t1 - tail_t1;
2281 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2282
2283 s2 += t1;
2284
2285 /* Renormalize (s1, s2) to (t1, s2) */
2286 t1 = s1 + s2;
2287 s2 = s2 - (t1 - s1);
2288
2289 t2 += s2;
2290
2291 /* Renormalize (t1, t2) */
2292 head_t1 = t1 + t2;
2293 tail_t1 = t2 - (head_t1 - t1);
2294 }
2295 head_rowtmp[0] = head_t1;
2296 tail_rowtmp[0] = tail_t1;
2297 /* Imaginary part */
2298 {
2299 /* Compute double_double = double * double. */
2300 double a1, a2, b1, b2, con;
2301
2302 con = vecval[1] * split;
2303 a1 = con - vecval[1];
2304 a1 = con - a1;
2305 a2 = vecval[1] - a1;
2306 con = cd[0] * split;
2307 b1 = con - cd[0];
2308 b1 = con - b1;
2309 b2 = cd[0] - b1;
2310
2311 head_t1 = vecval[1] * cd[0];
2312 tail_t1 =
2313 (((a1 * b1 - head_t1) + a1 * b2) + a2 * b1) +
2314 a2 * b2;
2315 }
2316 {
2317 /* Compute double_double = double * double. */
2318 double a1, a2, b1, b2, con;
2319
2320 con = vecval[0] * split;
2321 a1 = con - vecval[0];
2322 a1 = con - a1;
2323 a2 = vecval[0] - a1;
2324 con = cd[1] * split;
2325 b1 = con - cd[1];
2326 b1 = con - b1;
2327 b2 = cd[1] - b1;
2328
2329 head_t2 = vecval[0] * cd[1];
2330 tail_t2 =
2331 (((a1 * b1 - head_t2) + a1 * b2) + a2 * b1) +
2332 a2 * b2;
2333 }
2334 {
2335 /* Compute double-double = double-double + double-double. */
2336 double bv;
2337 double s1, s2, t1, t2;
2338
2339 /* Add two hi words. */
2340 s1 = head_t1 + head_t2;
2341 bv = s1 - head_t1;
2342 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2343
2344 /* Add two lo words. */
2345 t1 = tail_t1 + tail_t2;
2346 bv = t1 - tail_t1;
2347 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2348
2349 s2 += t1;
2350
2351 /* Renormalize (s1, s2) to (t1, s2) */
2352 t1 = s1 + s2;
2353 s2 = s2 - (t1 - s1);
2354
2355 t2 += s2;
2356
2357 /* Renormalize (t1, t2) */
2358 head_t1 = t1 + t2;
2359 tail_t1 = t2 - (head_t1 - t1);
2360 }
2361 head_rowtmp[1] = head_t1;
2362 tail_rowtmp[1] = tail_t1;
2363 }
2364 }
2365 }
2366 {
2367 double head_t, tail_t;
2368 double head_a, tail_a;
2369 double head_b, tail_b;
2370 /* Real part */
2371 head_a = head_rowsum[0];
2372 tail_a = tail_rowsum[0];
2373 head_b = head_rowtmp[0];
2374 tail_b = tail_rowtmp[0];
2375 {
2376 /* Compute double-double = double-double + double-double. */
2377 double bv;
2378 double s1, s2, t1, t2;
2379
2380 /* Add two hi words. */
2381 s1 = head_a + head_b;
2382 bv = s1 - head_a;
2383 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
2384
2385 /* Add two lo words. */
2386 t1 = tail_a + tail_b;
2387 bv = t1 - tail_a;
2388 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
2389
2390 s2 += t1;
2391
2392 /* Renormalize (s1, s2) to (t1, s2) */
2393 t1 = s1 + s2;
2394 s2 = s2 - (t1 - s1);
2395
2396 t2 += s2;
2397
2398 /* Renormalize (t1, t2) */
2399 head_t = t1 + t2;
2400 tail_t = t2 - (head_t - t1);
2401 }
2402 head_rowsum[0] = head_t;
2403 tail_rowsum[0] = tail_t;
2404 /* Imaginary part */
2405 head_a = head_rowsum[1];
2406 tail_a = tail_rowsum[1];
2407 head_b = head_rowtmp[1];
2408 tail_b = tail_rowtmp[1];
2409 {
2410 /* Compute double-double = double-double + double-double. */
2411 double bv;
2412 double s1, s2, t1, t2;
2413
2414 /* Add two hi words. */
2415 s1 = head_a + head_b;
2416 bv = s1 - head_a;
2417 s2 = ((head_b - bv) + (head_a - (s1 - bv)));
2418
2419 /* Add two lo words. */
2420 t1 = tail_a + tail_b;
2421 bv = t1 - tail_a;
2422 t2 = ((tail_b - bv) + (tail_a - (t1 - bv)));
2423
2424 s2 += t1;
2425
2426 /* Renormalize (s1, s2) to (t1, s2) */
2427 t1 = s1 + s2;
2428 s2 = s2 - (t1 - s1);
2429
2430 t2 += s2;
2431
2432 /* Renormalize (t1, t2) */
2433 head_t = t1 + t2;
2434 tail_t = t2 - (head_t - t1);
2435 }
2436 head_rowsum[1] = head_t;
2437 tail_rowsum[1] = tail_t;
2438 }
2439 stride--;
2440 tp_index += stride * inctp;
2441 x_index2 += incx;
2442 }
2443 {
2444 /* Compute complex-extra = complex-extra * complex-double. */
2445 double head_a0, tail_a0;
2446 double head_a1, tail_a1;
2447 double head_t1, tail_t1;
2448 double head_t2, tail_t2;
2449 head_a0 = head_rowsum[0];
2450 tail_a0 = tail_rowsum[0];
2451 head_a1 = head_rowsum[1];
2452 tail_a1 = tail_rowsum[1];
2453 /* real part */
2454 {
2455 /* Compute double-double = double-double * double. */
2456 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
2457
2458 con = head_a0 * split;
2459 a11 = con - head_a0;
2460 a11 = con - a11;
2461 a21 = head_a0 - a11;
2462 con = alpha_i[0] * split;
2463 b1 = con - alpha_i[0];
2464 b1 = con - b1;
2465 b2 = alpha_i[0] - b1;
2466
2467 c11 = head_a0 * alpha_i[0];
2468 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
2469
2470 c2 = tail_a0 * alpha_i[0];
2471 t1 = c11 + c2;
2472 t2 = (c2 - (t1 - c11)) + c21;
2473
2474 head_t1 = t1 + t2;
2475 tail_t1 = t2 - (head_t1 - t1);
2476 }
2477 {
2478 /* Compute double-double = double-double * double. */
2479 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
2480
2481 con = head_a1 * split;
2482 a11 = con - head_a1;
2483 a11 = con - a11;
2484 a21 = head_a1 - a11;
2485 con = alpha_i[1] * split;
2486 b1 = con - alpha_i[1];
2487 b1 = con - b1;
2488 b2 = alpha_i[1] - b1;
2489
2490 c11 = head_a1 * alpha_i[1];
2491 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
2492
2493 c2 = tail_a1 * alpha_i[1];
2494 t1 = c11 + c2;
2495 t2 = (c2 - (t1 - c11)) + c21;
2496
2497 head_t2 = t1 + t2;
2498 tail_t2 = t2 - (head_t2 - t1);
2499 }
2500 head_t2 = -head_t2;
2501 tail_t2 = -tail_t2;
2502 {
2503 /* Compute double-double = double-double + double-double. */
2504 double bv;
2505 double s1, s2, t1, t2;
2506
2507 /* Add two hi words. */
2508 s1 = head_t1 + head_t2;
2509 bv = s1 - head_t1;
2510 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2511
2512 /* Add two lo words. */
2513 t1 = tail_t1 + tail_t2;
2514 bv = t1 - tail_t1;
2515 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2516
2517 s2 += t1;
2518
2519 /* Renormalize (s1, s2) to (t1, s2) */
2520 t1 = s1 + s2;
2521 s2 = s2 - (t1 - s1);
2522
2523 t2 += s2;
2524
2525 /* Renormalize (t1, t2) */
2526 head_t1 = t1 + t2;
2527 tail_t1 = t2 - (head_t1 - t1);
2528 }
2529 head_result[0] = head_t1;
2530 tail_result[0] = tail_t1;
2531 /* imaginary part */
2532 {
2533 /* Compute double-double = double-double * double. */
2534 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
2535
2536 con = head_a1 * split;
2537 a11 = con - head_a1;
2538 a11 = con - a11;
2539 a21 = head_a1 - a11;
2540 con = alpha_i[0] * split;
2541 b1 = con - alpha_i[0];
2542 b1 = con - b1;
2543 b2 = alpha_i[0] - b1;
2544
2545 c11 = head_a1 * alpha_i[0];
2546 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
2547
2548 c2 = tail_a1 * alpha_i[0];
2549 t1 = c11 + c2;
2550 t2 = (c2 - (t1 - c11)) + c21;
2551
2552 head_t1 = t1 + t2;
2553 tail_t1 = t2 - (head_t1 - t1);
2554 }
2555 {
2556 /* Compute double-double = double-double * double. */
2557 double a11, a21, b1, b2, c11, c21, c2, con, t1, t2;
2558
2559 con = head_a0 * split;
2560 a11 = con - head_a0;
2561 a11 = con - a11;
2562 a21 = head_a0 - a11;
2563 con = alpha_i[1] * split;
2564 b1 = con - alpha_i[1];
2565 b1 = con - b1;
2566 b2 = alpha_i[1] - b1;
2567
2568 c11 = head_a0 * alpha_i[1];
2569 c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;
2570
2571 c2 = tail_a0 * alpha_i[1];
2572 t1 = c11 + c2;
2573 t2 = (c2 - (t1 - c11)) + c21;
2574
2575 head_t2 = t1 + t2;
2576 tail_t2 = t2 - (head_t2 - t1);
2577 }
2578 {
2579 /* Compute double-double = double-double + double-double. */
2580 double bv;
2581 double s1, s2, t1, t2;
2582
2583 /* Add two hi words. */
2584 s1 = head_t1 + head_t2;
2585 bv = s1 - head_t1;
2586 s2 = ((head_t2 - bv) + (head_t1 - (s1 - bv)));
2587
2588 /* Add two lo words. */
2589 t1 = tail_t1 + tail_t2;
2590 bv = t1 - tail_t1;
2591 t2 = ((tail_t2 - bv) + (tail_t1 - (t1 - bv)));
2592
2593 s2 += t1;
2594
2595 /* Renormalize (s1, s2) to (t1, s2) */
2596 t1 = s1 + s2;
2597 s2 = s2 - (t1 - s1);
2598
2599 t2 += s2;
2600
2601 /* Renormalize (t1, t2) */
2602 head_t1 = t1 + t2;
2603 tail_t1 = t2 - (head_t1 - t1);
2604 }
2605 head_result[1] = head_t1;
2606 tail_result[1] = tail_t1;
2607 }
2608
2609 x_i[x_index] = head_result[0];
2610 x_i[x_index + 1] = head_result[1];
2611 x_index -= incx;
2612 }
2613 }
2614 }
2615
2616
2617 }
2618 break;
2619 }
2620 }
2621
2622 }
2623