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