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