1 #include "blas_extended.h"
2 #include "blas_extended_private.h"
3
4 /*
5 * Purpose
6 * =======
7 *
8 * Computes y = alpha * ap * x + beta * y, where ap is a hermitian
9 * packed matrix.
10 *
11 * Arguments
12 * =========
13 *
14 * order (input) blas_order_type
15 * Order of ap; row or column major
16 *
17 * uplo (input) blas_uplo_type
18 * Whether ap is upper or lower
19 *
20 * n (input) int
21 * Dimension of ap and the length of vector x
22 *
23 * alpha (input) const void*
24 *
25 * ap (input) void*
26 *
27 * x (input) void*
28 *
29 * incx (input) int
30 * The stride for vector x.
31 *
32 * beta (input) const void*
33 *
34 * y (input/output) void*
35 *
36 * incy (input) int
37 * The stride for vector y.
38 *
39 */
BLAS_zhpmv_c_c(enum blas_order_type order,enum blas_uplo_type uplo,int n,const void * alpha,const void * ap,const void * x,int incx,const void * beta,void * y,int incy)40 void BLAS_zhpmv_c_c(enum blas_order_type order, enum blas_uplo_type uplo,
41 int n, const void *alpha, const void *ap,
42 const void *x, int incx, const void *beta, void *y,
43 int incy)
44 {
45 static const char routine_name[] = "BLAS_zhpmv_c_c";
46
47 {
48 enum blas_order_type order_i;
49
50 double *alpha_i = (double *) alpha;
51 double *beta_i = (double *) beta;
52 int matrix_row, step, ap_index, ap_start, x_index, x_start;
53 int y_start, y_index, incap;
54
55 const float *ap_i = (float *) ap;
56 const float *x_i = (float *) x;
57 double *y_i = (double *) y;
58 double rowsum[2];
59 double rowtmp[2];
60 float matval[2];
61 float vecval[2];
62 double resval[2];
63 double tmp1[2];
64 double tmp2[2];
65
66
67 if (n < 1)
68 return;
69 if (alpha_i[0] == 0.0 && alpha_i[1] == 0.0
70 && (beta_i[0] == 1.0 && beta_i[1] == 0.0))
71 return;
72
73 /* Check for error conditions. */
74 if (order != blas_colmajor && order != blas_rowmajor)
75 BLAS_error(routine_name, -1, order, NULL);
76 if (uplo != blas_upper && uplo != blas_lower)
77 BLAS_error(routine_name, -2, uplo, NULL);
78 if (incx == 0)
79 BLAS_error(routine_name, -7, incx, NULL);
80 if (incy == 0) {
81 BLAS_error(routine_name, -10, incy, NULL);
82 }
83
84
85
86 incap = 1;
87 incap *= 2;
88 incx *= 2;
89 incy *= 2;
90
91 if (incx < 0)
92 x_start = (-n + 1) * incx;
93 else
94 x_start = 0;
95 if (incy < 0)
96 y_start = (-n + 1) * incy;
97 else
98 y_start = 0;
99
100 if (uplo == blas_lower)
101 order_i = (order == blas_rowmajor) ? blas_colmajor : blas_rowmajor;
102 else
103 order_i = order;
104
105 if (alpha_i[0] == 0.0 && alpha_i[1] == 0.0) {
106 {
107 y_index = y_start;
108 for (matrix_row = 0; matrix_row < n; matrix_row++) {
109 resval[0] = y_i[y_index];
110 resval[1] = y_i[y_index + 1];
111
112 {
113 tmp2[0] =
114 (double) beta_i[0] * resval[0] - (double) beta_i[1] * resval[1];
115 tmp2[1] =
116 (double) beta_i[0] * resval[1] + (double) beta_i[1] * resval[0];
117 }
118
119 y_i[y_index] = tmp2[0];
120 y_i[y_index + 1] = tmp2[1];
121 y_index += incy;
122 }
123 }
124 } else {
125 if (order_i == blas_rowmajor) {
126 if ((alpha_i[0] == 1.0 && alpha_i[1] == 0.0)) {
127 if (beta_i[0] == 0.0 && beta_i[1] == 0.0) {
128 {
129 y_index = y_start;
130 ap_start = 0;
131 if (uplo == blas_upper) {
132 for (matrix_row = 0; matrix_row < n; matrix_row++) {
133 x_index = x_start;
134 ap_index = ap_start;
135 rowsum[0] = rowsum[1] = 0.0;
136 rowtmp[0] = rowtmp[1] = 0.0;
137 for (step = 0; step < matrix_row; step++) {
138 matval[0] = ap_i[ap_index];
139 matval[1] = ap_i[ap_index + 1];
140 vecval[0] = x_i[x_index];
141 vecval[1] = x_i[x_index + 1];
142 matval[1] = -matval[1];
143 {
144 rowtmp[0] =
145 (double) matval[0] * vecval[0] -
146 (double) matval[1] * vecval[1];
147 rowtmp[1] =
148 (double) matval[0] * vecval[1] +
149 (double) matval[1] * vecval[0];
150 }
151 rowsum[0] = rowsum[0] + rowtmp[0];
152 rowsum[1] = rowsum[1] + rowtmp[1];
153 ap_index += (n - step - 1) * incap;
154 x_index += incx;
155 }
156 /* need to do diagonal element without referencing the imaginary part */
157 matval[0] = ap_i[ap_index];
158 vecval[0] = x_i[x_index];
159 vecval[1] = x_i[x_index + 1];
160 {
161 rowtmp[0] = (double) vecval[0] * matval[0];
162 rowtmp[1] = (double) vecval[1] * matval[0];
163 }
164 rowsum[0] = rowsum[0] + rowtmp[0];
165 rowsum[1] = rowsum[1] + rowtmp[1];
166 ap_index += incap;
167 x_index += incx;
168 for (step = matrix_row + 1; step < n; step++) {
169 matval[0] = ap_i[ap_index];
170 matval[1] = ap_i[ap_index + 1];
171 vecval[0] = x_i[x_index];
172 vecval[1] = x_i[x_index + 1];
173
174 {
175 rowtmp[0] =
176 (double) matval[0] * vecval[0] -
177 (double) matval[1] * vecval[1];
178 rowtmp[1] =
179 (double) matval[0] * vecval[1] +
180 (double) matval[1] * vecval[0];
181 }
182 rowsum[0] = rowsum[0] + rowtmp[0];
183 rowsum[1] = rowsum[1] + rowtmp[1];
184 ap_index += incap;
185 x_index += incx;
186 }
187 tmp1[0] = rowsum[0];
188 tmp1[1] = rowsum[1];
189 y_i[y_index] = tmp1[0];
190 y_i[y_index + 1] = tmp1[1];
191 y_index += incy;
192 ap_start += incap;
193 }
194 } else { /* if uplo == ... */
195 for (matrix_row = 0; matrix_row < n; matrix_row++) {
196 x_index = x_start;
197 ap_index = ap_start;
198 rowsum[0] = rowsum[1] = 0.0;
199 rowtmp[0] = rowtmp[1] = 0.0;
200 for (step = 0; step < matrix_row; step++) {
201 matval[0] = ap_i[ap_index];
202 matval[1] = ap_i[ap_index + 1];
203 vecval[0] = x_i[x_index];
204 vecval[1] = x_i[x_index + 1];
205
206 {
207 rowtmp[0] =
208 (double) matval[0] * vecval[0] -
209 (double) matval[1] * vecval[1];
210 rowtmp[1] =
211 (double) matval[0] * vecval[1] +
212 (double) matval[1] * vecval[0];
213 }
214 rowsum[0] = rowsum[0] + rowtmp[0];
215 rowsum[1] = rowsum[1] + rowtmp[1];
216 ap_index += (n - step - 1) * incap;
217 x_index += incx;
218 }
219 /* need to do diagonal element without referencing the imaginary part */
220 matval[0] = ap_i[ap_index];
221 vecval[0] = x_i[x_index];
222 vecval[1] = x_i[x_index + 1];
223 {
224 rowtmp[0] = (double) vecval[0] * matval[0];
225 rowtmp[1] = (double) vecval[1] * matval[0];
226 }
227 rowsum[0] = rowsum[0] + rowtmp[0];
228 rowsum[1] = rowsum[1] + rowtmp[1];
229 ap_index += incap;
230 x_index += incx;
231 for (step = matrix_row + 1; step < n; step++) {
232 matval[0] = ap_i[ap_index];
233 matval[1] = ap_i[ap_index + 1];
234 vecval[0] = x_i[x_index];
235 vecval[1] = x_i[x_index + 1];
236 matval[1] = -matval[1];
237 {
238 rowtmp[0] =
239 (double) matval[0] * vecval[0] -
240 (double) matval[1] * vecval[1];
241 rowtmp[1] =
242 (double) matval[0] * vecval[1] +
243 (double) matval[1] * vecval[0];
244 }
245 rowsum[0] = rowsum[0] + rowtmp[0];
246 rowsum[1] = rowsum[1] + rowtmp[1];
247 ap_index += incap;
248 x_index += incx;
249 }
250 tmp1[0] = rowsum[0];
251 tmp1[1] = rowsum[1];
252 y_i[y_index] = tmp1[0];
253 y_i[y_index + 1] = tmp1[1];
254 y_index += incy;
255 ap_start += incap;
256 }
257 } /* end if uplo == blas_upper ... */
258 }
259 } else {
260 {
261 y_index = y_start;
262 ap_start = 0;
263 if (uplo == blas_upper) {
264 for (matrix_row = 0; matrix_row < n; matrix_row++) {
265 x_index = x_start;
266 ap_index = ap_start;
267 rowsum[0] = rowsum[1] = 0.0;
268 rowtmp[0] = rowtmp[1] = 0.0;
269 for (step = 0; step < matrix_row; step++) {
270 matval[0] = ap_i[ap_index];
271 matval[1] = ap_i[ap_index + 1];
272 vecval[0] = x_i[x_index];
273 vecval[1] = x_i[x_index + 1];
274 matval[1] = -matval[1];
275 {
276 rowtmp[0] =
277 (double) matval[0] * vecval[0] -
278 (double) matval[1] * vecval[1];
279 rowtmp[1] =
280 (double) matval[0] * vecval[1] +
281 (double) matval[1] * vecval[0];
282 }
283 rowsum[0] = rowsum[0] + rowtmp[0];
284 rowsum[1] = rowsum[1] + rowtmp[1];
285 ap_index += (n - step - 1) * incap;
286 x_index += incx;
287 }
288 /* need to do diagonal element without referencing the imaginary part */
289 matval[0] = ap_i[ap_index];
290 vecval[0] = x_i[x_index];
291 vecval[1] = x_i[x_index + 1];
292 {
293 rowtmp[0] = (double) vecval[0] * matval[0];
294 rowtmp[1] = (double) vecval[1] * matval[0];
295 }
296 rowsum[0] = rowsum[0] + rowtmp[0];
297 rowsum[1] = rowsum[1] + rowtmp[1];
298 ap_index += incap;
299 x_index += incx;
300 for (step = matrix_row + 1; step < n; step++) {
301 matval[0] = ap_i[ap_index];
302 matval[1] = ap_i[ap_index + 1];
303 vecval[0] = x_i[x_index];
304 vecval[1] = x_i[x_index + 1];
305
306 {
307 rowtmp[0] =
308 (double) matval[0] * vecval[0] -
309 (double) matval[1] * vecval[1];
310 rowtmp[1] =
311 (double) matval[0] * vecval[1] +
312 (double) matval[1] * vecval[0];
313 }
314 rowsum[0] = rowsum[0] + rowtmp[0];
315 rowsum[1] = rowsum[1] + rowtmp[1];
316 ap_index += incap;
317 x_index += incx;
318 }
319 resval[0] = y_i[y_index];
320 resval[1] = y_i[y_index + 1];
321 tmp1[0] = rowsum[0];
322 tmp1[1] = rowsum[1];
323 {
324 tmp2[0] =
325 (double) beta_i[0] * resval[0] -
326 (double) beta_i[1] * resval[1];
327 tmp2[1] =
328 (double) beta_i[0] * resval[1] +
329 (double) beta_i[1] * resval[0];
330 }
331 tmp2[0] = tmp1[0] + tmp2[0];
332 tmp2[1] = tmp1[1] + tmp2[1];
333 y_i[y_index] = tmp2[0];
334 y_i[y_index + 1] = tmp2[1];
335 y_index += incy;
336 ap_start += incap;
337 }
338 } else { /* if uplo == ... */
339 for (matrix_row = 0; matrix_row < n; matrix_row++) {
340 x_index = x_start;
341 ap_index = ap_start;
342 rowsum[0] = rowsum[1] = 0.0;
343 rowtmp[0] = rowtmp[1] = 0.0;
344 for (step = 0; step < matrix_row; step++) {
345 matval[0] = ap_i[ap_index];
346 matval[1] = ap_i[ap_index + 1];
347 vecval[0] = x_i[x_index];
348 vecval[1] = x_i[x_index + 1];
349
350 {
351 rowtmp[0] =
352 (double) matval[0] * vecval[0] -
353 (double) matval[1] * vecval[1];
354 rowtmp[1] =
355 (double) matval[0] * vecval[1] +
356 (double) matval[1] * vecval[0];
357 }
358 rowsum[0] = rowsum[0] + rowtmp[0];
359 rowsum[1] = rowsum[1] + rowtmp[1];
360 ap_index += (n - step - 1) * incap;
361 x_index += incx;
362 }
363 /* need to do diagonal element without referencing the imaginary part */
364 matval[0] = ap_i[ap_index];
365 vecval[0] = x_i[x_index];
366 vecval[1] = x_i[x_index + 1];
367 {
368 rowtmp[0] = (double) vecval[0] * matval[0];
369 rowtmp[1] = (double) vecval[1] * matval[0];
370 }
371 rowsum[0] = rowsum[0] + rowtmp[0];
372 rowsum[1] = rowsum[1] + rowtmp[1];
373 ap_index += incap;
374 x_index += incx;
375 for (step = matrix_row + 1; step < n; step++) {
376 matval[0] = ap_i[ap_index];
377 matval[1] = ap_i[ap_index + 1];
378 vecval[0] = x_i[x_index];
379 vecval[1] = x_i[x_index + 1];
380 matval[1] = -matval[1];
381 {
382 rowtmp[0] =
383 (double) matval[0] * vecval[0] -
384 (double) matval[1] * vecval[1];
385 rowtmp[1] =
386 (double) matval[0] * vecval[1] +
387 (double) matval[1] * vecval[0];
388 }
389 rowsum[0] = rowsum[0] + rowtmp[0];
390 rowsum[1] = rowsum[1] + rowtmp[1];
391 ap_index += incap;
392 x_index += incx;
393 }
394 resval[0] = y_i[y_index];
395 resval[1] = y_i[y_index + 1];
396 tmp1[0] = rowsum[0];
397 tmp1[1] = rowsum[1];
398 {
399 tmp2[0] =
400 (double) beta_i[0] * resval[0] -
401 (double) beta_i[1] * resval[1];
402 tmp2[1] =
403 (double) beta_i[0] * resval[1] +
404 (double) beta_i[1] * resval[0];
405 }
406 tmp2[0] = tmp1[0] + tmp2[0];
407 tmp2[1] = tmp1[1] + tmp2[1];
408 y_i[y_index] = tmp2[0];
409 y_i[y_index + 1] = tmp2[1];
410 y_index += incy;
411 ap_start += incap;
412 }
413 } /* end if uplo == blas_upper ... */
414 }
415 }
416 } else {
417 if (beta_i[0] == 0.0 && beta_i[1] == 0.0) {
418 {
419 y_index = y_start;
420 ap_start = 0;
421 if (uplo == blas_upper) {
422 for (matrix_row = 0; matrix_row < n; matrix_row++) {
423 x_index = x_start;
424 ap_index = ap_start;
425 rowsum[0] = rowsum[1] = 0.0;
426 rowtmp[0] = rowtmp[1] = 0.0;
427 for (step = 0; step < matrix_row; step++) {
428 matval[0] = ap_i[ap_index];
429 matval[1] = ap_i[ap_index + 1];
430 vecval[0] = x_i[x_index];
431 vecval[1] = x_i[x_index + 1];
432 matval[1] = -matval[1];
433 {
434 rowtmp[0] =
435 (double) matval[0] * vecval[0] -
436 (double) matval[1] * vecval[1];
437 rowtmp[1] =
438 (double) matval[0] * vecval[1] +
439 (double) matval[1] * vecval[0];
440 }
441 rowsum[0] = rowsum[0] + rowtmp[0];
442 rowsum[1] = rowsum[1] + rowtmp[1];
443 ap_index += (n - step - 1) * incap;
444 x_index += incx;
445 }
446 /* need to do diagonal element without referencing the imaginary part */
447 matval[0] = ap_i[ap_index];
448 vecval[0] = x_i[x_index];
449 vecval[1] = x_i[x_index + 1];
450 {
451 rowtmp[0] = (double) vecval[0] * matval[0];
452 rowtmp[1] = (double) vecval[1] * matval[0];
453 }
454 rowsum[0] = rowsum[0] + rowtmp[0];
455 rowsum[1] = rowsum[1] + rowtmp[1];
456 ap_index += incap;
457 x_index += incx;
458 for (step = matrix_row + 1; step < n; step++) {
459 matval[0] = ap_i[ap_index];
460 matval[1] = ap_i[ap_index + 1];
461 vecval[0] = x_i[x_index];
462 vecval[1] = x_i[x_index + 1];
463
464 {
465 rowtmp[0] =
466 (double) matval[0] * vecval[0] -
467 (double) matval[1] * vecval[1];
468 rowtmp[1] =
469 (double) matval[0] * vecval[1] +
470 (double) matval[1] * vecval[0];
471 }
472 rowsum[0] = rowsum[0] + rowtmp[0];
473 rowsum[1] = rowsum[1] + rowtmp[1];
474 ap_index += incap;
475 x_index += incx;
476 }
477 {
478 tmp1[0] =
479 (double) rowsum[0] * alpha_i[0] -
480 (double) rowsum[1] * alpha_i[1];
481 tmp1[1] =
482 (double) rowsum[0] * alpha_i[1] +
483 (double) rowsum[1] * alpha_i[0];
484 }
485 y_i[y_index] = tmp1[0];
486 y_i[y_index + 1] = tmp1[1];
487 y_index += incy;
488 ap_start += incap;
489 }
490 } else { /* if uplo == ... */
491 for (matrix_row = 0; matrix_row < n; matrix_row++) {
492 x_index = x_start;
493 ap_index = ap_start;
494 rowsum[0] = rowsum[1] = 0.0;
495 rowtmp[0] = rowtmp[1] = 0.0;
496 for (step = 0; step < matrix_row; step++) {
497 matval[0] = ap_i[ap_index];
498 matval[1] = ap_i[ap_index + 1];
499 vecval[0] = x_i[x_index];
500 vecval[1] = x_i[x_index + 1];
501
502 {
503 rowtmp[0] =
504 (double) matval[0] * vecval[0] -
505 (double) matval[1] * vecval[1];
506 rowtmp[1] =
507 (double) matval[0] * vecval[1] +
508 (double) matval[1] * vecval[0];
509 }
510 rowsum[0] = rowsum[0] + rowtmp[0];
511 rowsum[1] = rowsum[1] + rowtmp[1];
512 ap_index += (n - step - 1) * incap;
513 x_index += incx;
514 }
515 /* need to do diagonal element without referencing the imaginary part */
516 matval[0] = ap_i[ap_index];
517 vecval[0] = x_i[x_index];
518 vecval[1] = x_i[x_index + 1];
519 {
520 rowtmp[0] = (double) vecval[0] * matval[0];
521 rowtmp[1] = (double) vecval[1] * matval[0];
522 }
523 rowsum[0] = rowsum[0] + rowtmp[0];
524 rowsum[1] = rowsum[1] + rowtmp[1];
525 ap_index += incap;
526 x_index += incx;
527 for (step = matrix_row + 1; step < n; step++) {
528 matval[0] = ap_i[ap_index];
529 matval[1] = ap_i[ap_index + 1];
530 vecval[0] = x_i[x_index];
531 vecval[1] = x_i[x_index + 1];
532 matval[1] = -matval[1];
533 {
534 rowtmp[0] =
535 (double) matval[0] * vecval[0] -
536 (double) matval[1] * vecval[1];
537 rowtmp[1] =
538 (double) matval[0] * vecval[1] +
539 (double) matval[1] * vecval[0];
540 }
541 rowsum[0] = rowsum[0] + rowtmp[0];
542 rowsum[1] = rowsum[1] + rowtmp[1];
543 ap_index += incap;
544 x_index += incx;
545 }
546 {
547 tmp1[0] =
548 (double) rowsum[0] * alpha_i[0] -
549 (double) rowsum[1] * alpha_i[1];
550 tmp1[1] =
551 (double) rowsum[0] * alpha_i[1] +
552 (double) rowsum[1] * alpha_i[0];
553 }
554 y_i[y_index] = tmp1[0];
555 y_i[y_index + 1] = tmp1[1];
556 y_index += incy;
557 ap_start += incap;
558 }
559 } /* end if uplo == blas_upper ... */
560 }
561 } else {
562 {
563 y_index = y_start;
564 ap_start = 0;
565 if (uplo == blas_upper) {
566 for (matrix_row = 0; matrix_row < n; matrix_row++) {
567 x_index = x_start;
568 ap_index = ap_start;
569 rowsum[0] = rowsum[1] = 0.0;
570 rowtmp[0] = rowtmp[1] = 0.0;
571 for (step = 0; step < matrix_row; step++) {
572 matval[0] = ap_i[ap_index];
573 matval[1] = ap_i[ap_index + 1];
574 vecval[0] = x_i[x_index];
575 vecval[1] = x_i[x_index + 1];
576 matval[1] = -matval[1];
577 {
578 rowtmp[0] =
579 (double) matval[0] * vecval[0] -
580 (double) matval[1] * vecval[1];
581 rowtmp[1] =
582 (double) matval[0] * vecval[1] +
583 (double) matval[1] * vecval[0];
584 }
585 rowsum[0] = rowsum[0] + rowtmp[0];
586 rowsum[1] = rowsum[1] + rowtmp[1];
587 ap_index += (n - step - 1) * incap;
588 x_index += incx;
589 }
590 /* need to do diagonal element without referencing the imaginary part */
591 matval[0] = ap_i[ap_index];
592 vecval[0] = x_i[x_index];
593 vecval[1] = x_i[x_index + 1];
594 {
595 rowtmp[0] = (double) vecval[0] * matval[0];
596 rowtmp[1] = (double) vecval[1] * matval[0];
597 }
598 rowsum[0] = rowsum[0] + rowtmp[0];
599 rowsum[1] = rowsum[1] + rowtmp[1];
600 ap_index += incap;
601 x_index += incx;
602 for (step = matrix_row + 1; step < n; step++) {
603 matval[0] = ap_i[ap_index];
604 matval[1] = ap_i[ap_index + 1];
605 vecval[0] = x_i[x_index];
606 vecval[1] = x_i[x_index + 1];
607
608 {
609 rowtmp[0] =
610 (double) matval[0] * vecval[0] -
611 (double) matval[1] * vecval[1];
612 rowtmp[1] =
613 (double) matval[0] * vecval[1] +
614 (double) matval[1] * vecval[0];
615 }
616 rowsum[0] = rowsum[0] + rowtmp[0];
617 rowsum[1] = rowsum[1] + rowtmp[1];
618 ap_index += incap;
619 x_index += incx;
620 }
621 resval[0] = y_i[y_index];
622 resval[1] = y_i[y_index + 1];
623 {
624 tmp1[0] =
625 (double) rowsum[0] * alpha_i[0] -
626 (double) rowsum[1] * alpha_i[1];
627 tmp1[1] =
628 (double) rowsum[0] * alpha_i[1] +
629 (double) rowsum[1] * alpha_i[0];
630 }
631 {
632 tmp2[0] =
633 (double) beta_i[0] * resval[0] -
634 (double) beta_i[1] * resval[1];
635 tmp2[1] =
636 (double) beta_i[0] * resval[1] +
637 (double) beta_i[1] * resval[0];
638 }
639 tmp2[0] = tmp1[0] + tmp2[0];
640 tmp2[1] = tmp1[1] + tmp2[1];
641 y_i[y_index] = tmp2[0];
642 y_i[y_index + 1] = tmp2[1];
643 y_index += incy;
644 ap_start += incap;
645 }
646 } else { /* if uplo == ... */
647 for (matrix_row = 0; matrix_row < n; matrix_row++) {
648 x_index = x_start;
649 ap_index = ap_start;
650 rowsum[0] = rowsum[1] = 0.0;
651 rowtmp[0] = rowtmp[1] = 0.0;
652 for (step = 0; step < matrix_row; step++) {
653 matval[0] = ap_i[ap_index];
654 matval[1] = ap_i[ap_index + 1];
655 vecval[0] = x_i[x_index];
656 vecval[1] = x_i[x_index + 1];
657
658 {
659 rowtmp[0] =
660 (double) matval[0] * vecval[0] -
661 (double) matval[1] * vecval[1];
662 rowtmp[1] =
663 (double) matval[0] * vecval[1] +
664 (double) matval[1] * vecval[0];
665 }
666 rowsum[0] = rowsum[0] + rowtmp[0];
667 rowsum[1] = rowsum[1] + rowtmp[1];
668 ap_index += (n - step - 1) * incap;
669 x_index += incx;
670 }
671 /* need to do diagonal element without referencing the imaginary part */
672 matval[0] = ap_i[ap_index];
673 vecval[0] = x_i[x_index];
674 vecval[1] = x_i[x_index + 1];
675 {
676 rowtmp[0] = (double) vecval[0] * matval[0];
677 rowtmp[1] = (double) vecval[1] * matval[0];
678 }
679 rowsum[0] = rowsum[0] + rowtmp[0];
680 rowsum[1] = rowsum[1] + rowtmp[1];
681 ap_index += incap;
682 x_index += incx;
683 for (step = matrix_row + 1; step < n; step++) {
684 matval[0] = ap_i[ap_index];
685 matval[1] = ap_i[ap_index + 1];
686 vecval[0] = x_i[x_index];
687 vecval[1] = x_i[x_index + 1];
688 matval[1] = -matval[1];
689 {
690 rowtmp[0] =
691 (double) matval[0] * vecval[0] -
692 (double) matval[1] * vecval[1];
693 rowtmp[1] =
694 (double) matval[0] * vecval[1] +
695 (double) matval[1] * vecval[0];
696 }
697 rowsum[0] = rowsum[0] + rowtmp[0];
698 rowsum[1] = rowsum[1] + rowtmp[1];
699 ap_index += incap;
700 x_index += incx;
701 }
702 resval[0] = y_i[y_index];
703 resval[1] = y_i[y_index + 1];
704 {
705 tmp1[0] =
706 (double) rowsum[0] * alpha_i[0] -
707 (double) rowsum[1] * alpha_i[1];
708 tmp1[1] =
709 (double) rowsum[0] * alpha_i[1] +
710 (double) rowsum[1] * alpha_i[0];
711 }
712 {
713 tmp2[0] =
714 (double) beta_i[0] * resval[0] -
715 (double) beta_i[1] * resval[1];
716 tmp2[1] =
717 (double) beta_i[0] * resval[1] +
718 (double) beta_i[1] * resval[0];
719 }
720 tmp2[0] = tmp1[0] + tmp2[0];
721 tmp2[1] = tmp1[1] + tmp2[1];
722 y_i[y_index] = tmp2[0];
723 y_i[y_index + 1] = tmp2[1];
724 y_index += incy;
725 ap_start += incap;
726 }
727 } /* end if uplo == blas_upper ... */
728 }
729 }
730 }
731 } else {
732 if ((alpha_i[0] == 1.0 && alpha_i[1] == 0.0)) {
733 if (beta_i[0] == 0.0 && beta_i[1] == 0.0) {
734 {
735 y_index = y_start;
736 ap_start = 0;
737 if (uplo == blas_upper) {
738 for (matrix_row = 0; matrix_row < n; matrix_row++) {
739 x_index = x_start;
740 ap_index = ap_start;
741 rowsum[0] = rowsum[1] = 0.0;
742 rowtmp[0] = rowtmp[1] = 0.0;
743 for (step = 0; step < matrix_row; step++) {
744 matval[0] = ap_i[ap_index];
745 matval[1] = ap_i[ap_index + 1];
746 vecval[0] = x_i[x_index];
747 vecval[1] = x_i[x_index + 1];
748 matval[1] = -matval[1];
749 {
750 rowtmp[0] =
751 (double) matval[0] * vecval[0] -
752 (double) matval[1] * vecval[1];
753 rowtmp[1] =
754 (double) matval[0] * vecval[1] +
755 (double) matval[1] * vecval[0];
756 }
757 rowsum[0] = rowsum[0] + rowtmp[0];
758 rowsum[1] = rowsum[1] + rowtmp[1];
759 ap_index += incap;
760 x_index += incx;
761 }
762 /* need to do diagonal element without referencing the imaginary part */
763 matval[0] = ap_i[ap_index];
764 vecval[0] = x_i[x_index];
765 vecval[1] = x_i[x_index + 1];
766 {
767 rowtmp[0] = (double) vecval[0] * matval[0];
768 rowtmp[1] = (double) vecval[1] * matval[0];
769 }
770 rowsum[0] = rowsum[0] + rowtmp[0];
771 rowsum[1] = rowsum[1] + rowtmp[1];
772 ap_index += (step + 1) * incap;
773 x_index += incx;
774 for (step = matrix_row + 1; step < n; step++) {
775 matval[0] = ap_i[ap_index];
776 matval[1] = ap_i[ap_index + 1];
777 vecval[0] = x_i[x_index];
778 vecval[1] = x_i[x_index + 1];
779
780 {
781 rowtmp[0] =
782 (double) matval[0] * vecval[0] -
783 (double) matval[1] * vecval[1];
784 rowtmp[1] =
785 (double) matval[0] * vecval[1] +
786 (double) matval[1] * vecval[0];
787 }
788 rowsum[0] = rowsum[0] + rowtmp[0];
789 rowsum[1] = rowsum[1] + rowtmp[1];
790 ap_index += (step + 1) * incap;
791 x_index += incx;
792 }
793 tmp1[0] = rowsum[0];
794 tmp1[1] = rowsum[1];
795 y_i[y_index] = tmp1[0];
796 y_i[y_index + 1] = tmp1[1];
797 y_index += incy;
798 ap_start += (matrix_row + 1) * incap;
799 }
800 } else { /* if uplo == ... */
801 for (matrix_row = 0; matrix_row < n; matrix_row++) {
802 x_index = x_start;
803 ap_index = ap_start;
804 rowsum[0] = rowsum[1] = 0.0;
805 rowtmp[0] = rowtmp[1] = 0.0;
806 for (step = 0; step < matrix_row; step++) {
807 matval[0] = ap_i[ap_index];
808 matval[1] = ap_i[ap_index + 1];
809 vecval[0] = x_i[x_index];
810 vecval[1] = x_i[x_index + 1];
811
812 {
813 rowtmp[0] =
814 (double) matval[0] * vecval[0] -
815 (double) matval[1] * vecval[1];
816 rowtmp[1] =
817 (double) matval[0] * vecval[1] +
818 (double) matval[1] * vecval[0];
819 }
820 rowsum[0] = rowsum[0] + rowtmp[0];
821 rowsum[1] = rowsum[1] + rowtmp[1];
822 ap_index += incap;
823 x_index += incx;
824 }
825 /* need to do diagonal element without referencing the imaginary part */
826 matval[0] = ap_i[ap_index];
827 vecval[0] = x_i[x_index];
828 vecval[1] = x_i[x_index + 1];
829 {
830 rowtmp[0] = (double) vecval[0] * matval[0];
831 rowtmp[1] = (double) vecval[1] * matval[0];
832 }
833 rowsum[0] = rowsum[0] + rowtmp[0];
834 rowsum[1] = rowsum[1] + rowtmp[1];
835 ap_index += (step + 1) * incap;
836 x_index += incx;
837 for (step = matrix_row + 1; step < n; step++) {
838 matval[0] = ap_i[ap_index];
839 matval[1] = ap_i[ap_index + 1];
840 vecval[0] = x_i[x_index];
841 vecval[1] = x_i[x_index + 1];
842 matval[1] = -matval[1];
843 {
844 rowtmp[0] =
845 (double) matval[0] * vecval[0] -
846 (double) matval[1] * vecval[1];
847 rowtmp[1] =
848 (double) matval[0] * vecval[1] +
849 (double) matval[1] * vecval[0];
850 }
851 rowsum[0] = rowsum[0] + rowtmp[0];
852 rowsum[1] = rowsum[1] + rowtmp[1];
853 ap_index += (step + 1) * incap;
854 x_index += incx;
855 }
856 tmp1[0] = rowsum[0];
857 tmp1[1] = rowsum[1];
858 y_i[y_index] = tmp1[0];
859 y_i[y_index + 1] = tmp1[1];
860 y_index += incy;
861 ap_start += (matrix_row + 1) * incap;
862 }
863 } /* end if uplo == blas_upper ... */
864 }
865 } else {
866 {
867 y_index = y_start;
868 ap_start = 0;
869 if (uplo == blas_upper) {
870 for (matrix_row = 0; matrix_row < n; matrix_row++) {
871 x_index = x_start;
872 ap_index = ap_start;
873 rowsum[0] = rowsum[1] = 0.0;
874 rowtmp[0] = rowtmp[1] = 0.0;
875 for (step = 0; step < matrix_row; step++) {
876 matval[0] = ap_i[ap_index];
877 matval[1] = ap_i[ap_index + 1];
878 vecval[0] = x_i[x_index];
879 vecval[1] = x_i[x_index + 1];
880 matval[1] = -matval[1];
881 {
882 rowtmp[0] =
883 (double) matval[0] * vecval[0] -
884 (double) matval[1] * vecval[1];
885 rowtmp[1] =
886 (double) matval[0] * vecval[1] +
887 (double) matval[1] * vecval[0];
888 }
889 rowsum[0] = rowsum[0] + rowtmp[0];
890 rowsum[1] = rowsum[1] + rowtmp[1];
891 ap_index += incap;
892 x_index += incx;
893 }
894 /* need to do diagonal element without referencing the imaginary part */
895 matval[0] = ap_i[ap_index];
896 vecval[0] = x_i[x_index];
897 vecval[1] = x_i[x_index + 1];
898 {
899 rowtmp[0] = (double) vecval[0] * matval[0];
900 rowtmp[1] = (double) vecval[1] * matval[0];
901 }
902 rowsum[0] = rowsum[0] + rowtmp[0];
903 rowsum[1] = rowsum[1] + rowtmp[1];
904 ap_index += (step + 1) * incap;
905 x_index += incx;
906 for (step = matrix_row + 1; step < n; step++) {
907 matval[0] = ap_i[ap_index];
908 matval[1] = ap_i[ap_index + 1];
909 vecval[0] = x_i[x_index];
910 vecval[1] = x_i[x_index + 1];
911
912 {
913 rowtmp[0] =
914 (double) matval[0] * vecval[0] -
915 (double) matval[1] * vecval[1];
916 rowtmp[1] =
917 (double) matval[0] * vecval[1] +
918 (double) matval[1] * vecval[0];
919 }
920 rowsum[0] = rowsum[0] + rowtmp[0];
921 rowsum[1] = rowsum[1] + rowtmp[1];
922 ap_index += (step + 1) * incap;
923 x_index += incx;
924 }
925 resval[0] = y_i[y_index];
926 resval[1] = y_i[y_index + 1];
927 tmp1[0] = rowsum[0];
928 tmp1[1] = rowsum[1];
929 {
930 tmp2[0] =
931 (double) beta_i[0] * resval[0] -
932 (double) beta_i[1] * resval[1];
933 tmp2[1] =
934 (double) beta_i[0] * resval[1] +
935 (double) beta_i[1] * resval[0];
936 }
937 tmp2[0] = tmp1[0] + tmp2[0];
938 tmp2[1] = tmp1[1] + tmp2[1];
939 y_i[y_index] = tmp2[0];
940 y_i[y_index + 1] = tmp2[1];
941 y_index += incy;
942 ap_start += (matrix_row + 1) * incap;
943 }
944 } else { /* if uplo == ... */
945 for (matrix_row = 0; matrix_row < n; matrix_row++) {
946 x_index = x_start;
947 ap_index = ap_start;
948 rowsum[0] = rowsum[1] = 0.0;
949 rowtmp[0] = rowtmp[1] = 0.0;
950 for (step = 0; step < matrix_row; step++) {
951 matval[0] = ap_i[ap_index];
952 matval[1] = ap_i[ap_index + 1];
953 vecval[0] = x_i[x_index];
954 vecval[1] = x_i[x_index + 1];
955
956 {
957 rowtmp[0] =
958 (double) matval[0] * vecval[0] -
959 (double) matval[1] * vecval[1];
960 rowtmp[1] =
961 (double) matval[0] * vecval[1] +
962 (double) matval[1] * vecval[0];
963 }
964 rowsum[0] = rowsum[0] + rowtmp[0];
965 rowsum[1] = rowsum[1] + rowtmp[1];
966 ap_index += incap;
967 x_index += incx;
968 }
969 /* need to do diagonal element without referencing the imaginary part */
970 matval[0] = ap_i[ap_index];
971 vecval[0] = x_i[x_index];
972 vecval[1] = x_i[x_index + 1];
973 {
974 rowtmp[0] = (double) vecval[0] * matval[0];
975 rowtmp[1] = (double) vecval[1] * matval[0];
976 }
977 rowsum[0] = rowsum[0] + rowtmp[0];
978 rowsum[1] = rowsum[1] + rowtmp[1];
979 ap_index += (step + 1) * incap;
980 x_index += incx;
981 for (step = matrix_row + 1; step < n; step++) {
982 matval[0] = ap_i[ap_index];
983 matval[1] = ap_i[ap_index + 1];
984 vecval[0] = x_i[x_index];
985 vecval[1] = x_i[x_index + 1];
986 matval[1] = -matval[1];
987 {
988 rowtmp[0] =
989 (double) matval[0] * vecval[0] -
990 (double) matval[1] * vecval[1];
991 rowtmp[1] =
992 (double) matval[0] * vecval[1] +
993 (double) matval[1] * vecval[0];
994 }
995 rowsum[0] = rowsum[0] + rowtmp[0];
996 rowsum[1] = rowsum[1] + rowtmp[1];
997 ap_index += (step + 1) * incap;
998 x_index += incx;
999 }
1000 resval[0] = y_i[y_index];
1001 resval[1] = y_i[y_index + 1];
1002 tmp1[0] = rowsum[0];
1003 tmp1[1] = rowsum[1];
1004 {
1005 tmp2[0] =
1006 (double) beta_i[0] * resval[0] -
1007 (double) beta_i[1] * resval[1];
1008 tmp2[1] =
1009 (double) beta_i[0] * resval[1] +
1010 (double) beta_i[1] * resval[0];
1011 }
1012 tmp2[0] = tmp1[0] + tmp2[0];
1013 tmp2[1] = tmp1[1] + tmp2[1];
1014 y_i[y_index] = tmp2[0];
1015 y_i[y_index + 1] = tmp2[1];
1016 y_index += incy;
1017 ap_start += (matrix_row + 1) * incap;
1018 }
1019 } /* end if uplo == blas_upper ... */
1020 }
1021 }
1022 } else {
1023 if (beta_i[0] == 0.0 && beta_i[1] == 0.0) {
1024 {
1025 y_index = y_start;
1026 ap_start = 0;
1027 if (uplo == blas_upper) {
1028 for (matrix_row = 0; matrix_row < n; matrix_row++) {
1029 x_index = x_start;
1030 ap_index = ap_start;
1031 rowsum[0] = rowsum[1] = 0.0;
1032 rowtmp[0] = rowtmp[1] = 0.0;
1033 for (step = 0; step < matrix_row; step++) {
1034 matval[0] = ap_i[ap_index];
1035 matval[1] = ap_i[ap_index + 1];
1036 vecval[0] = x_i[x_index];
1037 vecval[1] = x_i[x_index + 1];
1038 matval[1] = -matval[1];
1039 {
1040 rowtmp[0] =
1041 (double) matval[0] * vecval[0] -
1042 (double) matval[1] * vecval[1];
1043 rowtmp[1] =
1044 (double) matval[0] * vecval[1] +
1045 (double) matval[1] * vecval[0];
1046 }
1047 rowsum[0] = rowsum[0] + rowtmp[0];
1048 rowsum[1] = rowsum[1] + rowtmp[1];
1049 ap_index += incap;
1050 x_index += incx;
1051 }
1052 /* need to do diagonal element without referencing the imaginary part */
1053 matval[0] = ap_i[ap_index];
1054 vecval[0] = x_i[x_index];
1055 vecval[1] = x_i[x_index + 1];
1056 {
1057 rowtmp[0] = (double) vecval[0] * matval[0];
1058 rowtmp[1] = (double) vecval[1] * matval[0];
1059 }
1060 rowsum[0] = rowsum[0] + rowtmp[0];
1061 rowsum[1] = rowsum[1] + rowtmp[1];
1062 ap_index += (step + 1) * incap;
1063 x_index += incx;
1064 for (step = matrix_row + 1; step < n; step++) {
1065 matval[0] = ap_i[ap_index];
1066 matval[1] = ap_i[ap_index + 1];
1067 vecval[0] = x_i[x_index];
1068 vecval[1] = x_i[x_index + 1];
1069
1070 {
1071 rowtmp[0] =
1072 (double) matval[0] * vecval[0] -
1073 (double) matval[1] * vecval[1];
1074 rowtmp[1] =
1075 (double) matval[0] * vecval[1] +
1076 (double) matval[1] * vecval[0];
1077 }
1078 rowsum[0] = rowsum[0] + rowtmp[0];
1079 rowsum[1] = rowsum[1] + rowtmp[1];
1080 ap_index += (step + 1) * incap;
1081 x_index += incx;
1082 }
1083 {
1084 tmp1[0] =
1085 (double) rowsum[0] * alpha_i[0] -
1086 (double) rowsum[1] * alpha_i[1];
1087 tmp1[1] =
1088 (double) rowsum[0] * alpha_i[1] +
1089 (double) rowsum[1] * alpha_i[0];
1090 }
1091 y_i[y_index] = tmp1[0];
1092 y_i[y_index + 1] = tmp1[1];
1093 y_index += incy;
1094 ap_start += (matrix_row + 1) * incap;
1095 }
1096 } else { /* if uplo == ... */
1097 for (matrix_row = 0; matrix_row < n; matrix_row++) {
1098 x_index = x_start;
1099 ap_index = ap_start;
1100 rowsum[0] = rowsum[1] = 0.0;
1101 rowtmp[0] = rowtmp[1] = 0.0;
1102 for (step = 0; step < matrix_row; step++) {
1103 matval[0] = ap_i[ap_index];
1104 matval[1] = ap_i[ap_index + 1];
1105 vecval[0] = x_i[x_index];
1106 vecval[1] = x_i[x_index + 1];
1107
1108 {
1109 rowtmp[0] =
1110 (double) matval[0] * vecval[0] -
1111 (double) matval[1] * vecval[1];
1112 rowtmp[1] =
1113 (double) matval[0] * vecval[1] +
1114 (double) matval[1] * vecval[0];
1115 }
1116 rowsum[0] = rowsum[0] + rowtmp[0];
1117 rowsum[1] = rowsum[1] + rowtmp[1];
1118 ap_index += incap;
1119 x_index += incx;
1120 }
1121 /* need to do diagonal element without referencing the imaginary part */
1122 matval[0] = ap_i[ap_index];
1123 vecval[0] = x_i[x_index];
1124 vecval[1] = x_i[x_index + 1];
1125 {
1126 rowtmp[0] = (double) vecval[0] * matval[0];
1127 rowtmp[1] = (double) vecval[1] * matval[0];
1128 }
1129 rowsum[0] = rowsum[0] + rowtmp[0];
1130 rowsum[1] = rowsum[1] + rowtmp[1];
1131 ap_index += (step + 1) * incap;
1132 x_index += incx;
1133 for (step = matrix_row + 1; step < n; step++) {
1134 matval[0] = ap_i[ap_index];
1135 matval[1] = ap_i[ap_index + 1];
1136 vecval[0] = x_i[x_index];
1137 vecval[1] = x_i[x_index + 1];
1138 matval[1] = -matval[1];
1139 {
1140 rowtmp[0] =
1141 (double) matval[0] * vecval[0] -
1142 (double) matval[1] * vecval[1];
1143 rowtmp[1] =
1144 (double) matval[0] * vecval[1] +
1145 (double) matval[1] * vecval[0];
1146 }
1147 rowsum[0] = rowsum[0] + rowtmp[0];
1148 rowsum[1] = rowsum[1] + rowtmp[1];
1149 ap_index += (step + 1) * incap;
1150 x_index += incx;
1151 }
1152 {
1153 tmp1[0] =
1154 (double) rowsum[0] * alpha_i[0] -
1155 (double) rowsum[1] * alpha_i[1];
1156 tmp1[1] =
1157 (double) rowsum[0] * alpha_i[1] +
1158 (double) rowsum[1] * alpha_i[0];
1159 }
1160 y_i[y_index] = tmp1[0];
1161 y_i[y_index + 1] = tmp1[1];
1162 y_index += incy;
1163 ap_start += (matrix_row + 1) * incap;
1164 }
1165 } /* end if uplo == blas_upper ... */
1166 }
1167 } else {
1168 {
1169 y_index = y_start;
1170 ap_start = 0;
1171 if (uplo == blas_upper) {
1172 for (matrix_row = 0; matrix_row < n; matrix_row++) {
1173 x_index = x_start;
1174 ap_index = ap_start;
1175 rowsum[0] = rowsum[1] = 0.0;
1176 rowtmp[0] = rowtmp[1] = 0.0;
1177 for (step = 0; step < matrix_row; step++) {
1178 matval[0] = ap_i[ap_index];
1179 matval[1] = ap_i[ap_index + 1];
1180 vecval[0] = x_i[x_index];
1181 vecval[1] = x_i[x_index + 1];
1182 matval[1] = -matval[1];
1183 {
1184 rowtmp[0] =
1185 (double) matval[0] * vecval[0] -
1186 (double) matval[1] * vecval[1];
1187 rowtmp[1] =
1188 (double) matval[0] * vecval[1] +
1189 (double) matval[1] * vecval[0];
1190 }
1191 rowsum[0] = rowsum[0] + rowtmp[0];
1192 rowsum[1] = rowsum[1] + rowtmp[1];
1193 ap_index += incap;
1194 x_index += incx;
1195 }
1196 /* need to do diagonal element without referencing the imaginary part */
1197 matval[0] = ap_i[ap_index];
1198 vecval[0] = x_i[x_index];
1199 vecval[1] = x_i[x_index + 1];
1200 {
1201 rowtmp[0] = (double) vecval[0] * matval[0];
1202 rowtmp[1] = (double) vecval[1] * matval[0];
1203 }
1204 rowsum[0] = rowsum[0] + rowtmp[0];
1205 rowsum[1] = rowsum[1] + rowtmp[1];
1206 ap_index += (step + 1) * incap;
1207 x_index += incx;
1208 for (step = matrix_row + 1; step < n; step++) {
1209 matval[0] = ap_i[ap_index];
1210 matval[1] = ap_i[ap_index + 1];
1211 vecval[0] = x_i[x_index];
1212 vecval[1] = x_i[x_index + 1];
1213
1214 {
1215 rowtmp[0] =
1216 (double) matval[0] * vecval[0] -
1217 (double) matval[1] * vecval[1];
1218 rowtmp[1] =
1219 (double) matval[0] * vecval[1] +
1220 (double) matval[1] * vecval[0];
1221 }
1222 rowsum[0] = rowsum[0] + rowtmp[0];
1223 rowsum[1] = rowsum[1] + rowtmp[1];
1224 ap_index += (step + 1) * incap;
1225 x_index += incx;
1226 }
1227 resval[0] = y_i[y_index];
1228 resval[1] = y_i[y_index + 1];
1229 {
1230 tmp1[0] =
1231 (double) rowsum[0] * alpha_i[0] -
1232 (double) rowsum[1] * alpha_i[1];
1233 tmp1[1] =
1234 (double) rowsum[0] * alpha_i[1] +
1235 (double) rowsum[1] * alpha_i[0];
1236 }
1237 {
1238 tmp2[0] =
1239 (double) beta_i[0] * resval[0] -
1240 (double) beta_i[1] * resval[1];
1241 tmp2[1] =
1242 (double) beta_i[0] * resval[1] +
1243 (double) beta_i[1] * resval[0];
1244 }
1245 tmp2[0] = tmp1[0] + tmp2[0];
1246 tmp2[1] = tmp1[1] + tmp2[1];
1247 y_i[y_index] = tmp2[0];
1248 y_i[y_index + 1] = tmp2[1];
1249 y_index += incy;
1250 ap_start += (matrix_row + 1) * incap;
1251 }
1252 } else { /* if uplo == ... */
1253 for (matrix_row = 0; matrix_row < n; matrix_row++) {
1254 x_index = x_start;
1255 ap_index = ap_start;
1256 rowsum[0] = rowsum[1] = 0.0;
1257 rowtmp[0] = rowtmp[1] = 0.0;
1258 for (step = 0; step < matrix_row; step++) {
1259 matval[0] = ap_i[ap_index];
1260 matval[1] = ap_i[ap_index + 1];
1261 vecval[0] = x_i[x_index];
1262 vecval[1] = x_i[x_index + 1];
1263
1264 {
1265 rowtmp[0] =
1266 (double) matval[0] * vecval[0] -
1267 (double) matval[1] * vecval[1];
1268 rowtmp[1] =
1269 (double) matval[0] * vecval[1] +
1270 (double) matval[1] * vecval[0];
1271 }
1272 rowsum[0] = rowsum[0] + rowtmp[0];
1273 rowsum[1] = rowsum[1] + rowtmp[1];
1274 ap_index += incap;
1275 x_index += incx;
1276 }
1277 /* need to do diagonal element without referencing the imaginary part */
1278 matval[0] = ap_i[ap_index];
1279 vecval[0] = x_i[x_index];
1280 vecval[1] = x_i[x_index + 1];
1281 {
1282 rowtmp[0] = (double) vecval[0] * matval[0];
1283 rowtmp[1] = (double) vecval[1] * matval[0];
1284 }
1285 rowsum[0] = rowsum[0] + rowtmp[0];
1286 rowsum[1] = rowsum[1] + rowtmp[1];
1287 ap_index += (step + 1) * incap;
1288 x_index += incx;
1289 for (step = matrix_row + 1; step < n; step++) {
1290 matval[0] = ap_i[ap_index];
1291 matval[1] = ap_i[ap_index + 1];
1292 vecval[0] = x_i[x_index];
1293 vecval[1] = x_i[x_index + 1];
1294 matval[1] = -matval[1];
1295 {
1296 rowtmp[0] =
1297 (double) matval[0] * vecval[0] -
1298 (double) matval[1] * vecval[1];
1299 rowtmp[1] =
1300 (double) matval[0] * vecval[1] +
1301 (double) matval[1] * vecval[0];
1302 }
1303 rowsum[0] = rowsum[0] + rowtmp[0];
1304 rowsum[1] = rowsum[1] + rowtmp[1];
1305 ap_index += (step + 1) * incap;
1306 x_index += incx;
1307 }
1308 resval[0] = y_i[y_index];
1309 resval[1] = y_i[y_index + 1];
1310 {
1311 tmp1[0] =
1312 (double) rowsum[0] * alpha_i[0] -
1313 (double) rowsum[1] * alpha_i[1];
1314 tmp1[1] =
1315 (double) rowsum[0] * alpha_i[1] +
1316 (double) rowsum[1] * alpha_i[0];
1317 }
1318 {
1319 tmp2[0] =
1320 (double) beta_i[0] * resval[0] -
1321 (double) beta_i[1] * resval[1];
1322 tmp2[1] =
1323 (double) beta_i[0] * resval[1] +
1324 (double) beta_i[1] * resval[0];
1325 }
1326 tmp2[0] = tmp1[0] + tmp2[0];
1327 tmp2[1] = tmp1[1] + tmp2[1];
1328 y_i[y_index] = tmp2[0];
1329 y_i[y_index + 1] = tmp2[1];
1330 y_index += incy;
1331 ap_start += (matrix_row + 1) * incap;
1332 }
1333 } /* end if uplo == blas_upper ... */
1334 }
1335 }
1336 }
1337 }
1338 } /* end alpha != 0 */
1339
1340 }
1341 }
1342