LAPACK  3.8.0
LAPACK: Linear Algebra PACKage
c_zblas2.c
Go to the documentation of this file.
1 /*
2  * Written by D.P. Manley, Digital Equipment Corporation.
3  * Prefixed "C_" to BLAS routines and their declarations.
4  *
5  * Modified by T. H. Do, 4/08/98, SGI/CRAY Research.
6  */
7 #include <stdlib.h>
8 #include "cblas.h"
9 #include "cblas_test.h"
10 
11 void F77_zgemv(int *layout, char *transp, int *m, int *n,
12  const void *alpha,
13  CBLAS_TEST_ZOMPLEX *a, int *lda, const void *x, int *incx,
14  const void *beta, void *y, int *incy) {
15 
17  int i,j,LDA;
18  CBLAS_TRANSPOSE trans;
19 
20  get_transpose_type(transp, &trans);
21  if (*layout == TEST_ROW_MJR) {
22  LDA = *n+1;
23  A = (CBLAS_TEST_ZOMPLEX *)malloc( (*m)*LDA*sizeof( CBLAS_TEST_ZOMPLEX) );
24  for( i=0; i<*m; i++ )
25  for( j=0; j<*n; j++ ){
26  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
27  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
28  }
29  cblas_zgemv( CblasRowMajor, trans, *m, *n, alpha, A, LDA, x, *incx,
30  beta, y, *incy );
31  free(A);
32  }
33  else if (*layout == TEST_COL_MJR)
34  cblas_zgemv( CblasColMajor, trans,
35  *m, *n, alpha, a, *lda, x, *incx, beta, y, *incy );
36  else
37  cblas_zgemv( UNDEFINED, trans,
38  *m, *n, alpha, a, *lda, x, *incx, beta, y, *incy );
39 }
40 
41 void F77_zgbmv(int *layout, char *transp, int *m, int *n, int *kl, int *ku,
42  CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *a, int *lda,
43  CBLAS_TEST_ZOMPLEX *x, int *incx,
44  CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy) {
45 
47  int i,j,irow,jcol,LDA;
48  CBLAS_TRANSPOSE trans;
49 
50  get_transpose_type(transp, &trans);
51  if (*layout == TEST_ROW_MJR) {
52  LDA = *ku+*kl+2;
53  A=( CBLAS_TEST_ZOMPLEX* )malloc((*n+*kl)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
54  for( i=0; i<*ku; i++ ){
55  irow=*ku+*kl-i;
56  jcol=(*ku)-i;
57  for( j=jcol; j<*n; j++ ){
58  A[ LDA*(j-jcol)+irow ].real=a[ (*lda)*j+i ].real;
59  A[ LDA*(j-jcol)+irow ].imag=a[ (*lda)*j+i ].imag;
60  }
61  }
62  i=*ku;
63  irow=*ku+*kl-i;
64  for( j=0; j<*n; j++ ){
65  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
66  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
67  }
68  for( i=*ku+1; i<*ku+*kl+1; i++ ){
69  irow=*ku+*kl-i;
70  jcol=i-(*ku);
71  for( j=jcol; j<(*n+*kl); j++ ){
72  A[ LDA*j+irow ].real=a[ (*lda)*(j-jcol)+i ].real;
73  A[ LDA*j+irow ].imag=a[ (*lda)*(j-jcol)+i ].imag;
74  }
75  }
76  cblas_zgbmv( CblasRowMajor, trans, *m, *n, *kl, *ku, alpha, A, LDA, x,
77  *incx, beta, y, *incy );
78  free(A);
79  }
80  else if (*layout == TEST_COL_MJR)
81  cblas_zgbmv( CblasColMajor, trans, *m, *n, *kl, *ku, alpha, a, *lda, x,
82  *incx, beta, y, *incy );
83  else
84  cblas_zgbmv( UNDEFINED, trans, *m, *n, *kl, *ku, alpha, a, *lda, x,
85  *incx, beta, y, *incy );
86 }
87 
88 void F77_zgeru(int *layout, int *m, int *n, CBLAS_TEST_ZOMPLEX *alpha,
89  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy,
90  CBLAS_TEST_ZOMPLEX *a, int *lda){
91 
93  int i,j,LDA;
94 
95  if (*layout == TEST_ROW_MJR) {
96  LDA = *n+1;
97  A=(CBLAS_TEST_ZOMPLEX*)malloc((*m)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
98  for( i=0; i<*m; i++ )
99  for( j=0; j<*n; j++ ){
100  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
101  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
102  }
103  cblas_zgeru( CblasRowMajor, *m, *n, alpha, x, *incx, y, *incy, A, LDA );
104  for( i=0; i<*m; i++ )
105  for( j=0; j<*n; j++ ){
106  a[ (*lda)*j+i ].real=A[ LDA*i+j ].real;
107  a[ (*lda)*j+i ].imag=A[ LDA*i+j ].imag;
108  }
109  free(A);
110  }
111  else if (*layout == TEST_COL_MJR)
112  cblas_zgeru( CblasColMajor, *m, *n, alpha, x, *incx, y, *incy, a, *lda );
113  else
114  cblas_zgeru( UNDEFINED, *m, *n, alpha, x, *incx, y, *incy, a, *lda );
115 }
116 
117 void F77_zgerc(int *layout, int *m, int *n, CBLAS_TEST_ZOMPLEX *alpha,
118  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy,
119  CBLAS_TEST_ZOMPLEX *a, int *lda) {
121  int i,j,LDA;
122 
123  if (*layout == TEST_ROW_MJR) {
124  LDA = *n+1;
125  A=(CBLAS_TEST_ZOMPLEX* )malloc((*m)*LDA*sizeof(CBLAS_TEST_ZOMPLEX ) );
126  for( i=0; i<*m; i++ )
127  for( j=0; j<*n; j++ ){
128  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
129  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
130  }
131  cblas_zgerc( CblasRowMajor, *m, *n, alpha, x, *incx, y, *incy, A, LDA );
132  for( i=0; i<*m; i++ )
133  for( j=0; j<*n; j++ ){
134  a[ (*lda)*j+i ].real=A[ LDA*i+j ].real;
135  a[ (*lda)*j+i ].imag=A[ LDA*i+j ].imag;
136  }
137  free(A);
138  }
139  else if (*layout == TEST_COL_MJR)
140  cblas_zgerc( CblasColMajor, *m, *n, alpha, x, *incx, y, *incy, a, *lda );
141  else
142  cblas_zgerc( UNDEFINED, *m, *n, alpha, x, *incx, y, *incy, a, *lda );
143 }
144 
145 void F77_zhemv(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha,
146  CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x,
147  int *incx, CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy){
148 
150  int i,j,LDA;
151  CBLAS_UPLO uplo;
152 
153  get_uplo_type(uplow,&uplo);
154 
155  if (*layout == TEST_ROW_MJR) {
156  LDA = *n+1;
157  A = (CBLAS_TEST_ZOMPLEX *)malloc((*n)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
158  for( i=0; i<*n; i++ )
159  for( j=0; j<*n; j++ ){
160  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
161  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
162  }
163  cblas_zhemv( CblasRowMajor, uplo, *n, alpha, A, LDA, x, *incx,
164  beta, y, *incy );
165  free(A);
166  }
167  else if (*layout == TEST_COL_MJR)
168  cblas_zhemv( CblasColMajor, uplo, *n, alpha, a, *lda, x, *incx,
169  beta, y, *incy );
170  else
171  cblas_zhemv( UNDEFINED, uplo, *n, alpha, a, *lda, x, *incx,
172  beta, y, *incy );
173 }
174 
175 void F77_zhbmv(int *layout, char *uplow, int *n, int *k,
176  CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *a, int *lda,
177  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *beta,
178  CBLAS_TEST_ZOMPLEX *y, int *incy){
179 
181 int i,irow,j,jcol,LDA;
182 
183  CBLAS_UPLO uplo;
184 
185  get_uplo_type(uplow,&uplo);
186 
187  if (*layout == TEST_ROW_MJR) {
188  if (uplo != CblasUpper && uplo != CblasLower )
189  cblas_zhbmv(CblasRowMajor, UNDEFINED, *n, *k, alpha, a, *lda, x,
190  *incx, beta, y, *incy );
191  else {
192  LDA = *k+2;
193  A =(CBLAS_TEST_ZOMPLEX*)malloc((*n+*k)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
194  if (uplo == CblasUpper) {
195  for( i=0; i<*k; i++ ){
196  irow=*k-i;
197  jcol=(*k)-i;
198  for( j=jcol; j<*n; j++ ) {
199  A[ LDA*(j-jcol)+irow ].real=a[ (*lda)*j+i ].real;
200  A[ LDA*(j-jcol)+irow ].imag=a[ (*lda)*j+i ].imag;
201  }
202  }
203  i=*k;
204  irow=*k-i;
205  for( j=0; j<*n; j++ ) {
206  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
207  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
208  }
209  }
210  else {
211  i=0;
212  irow=*k-i;
213  for( j=0; j<*n; j++ ) {
214  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
215  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
216  }
217  for( i=1; i<*k+1; i++ ){
218  irow=*k-i;
219  jcol=i;
220  for( j=jcol; j<(*n+*k); j++ ) {
221  A[ LDA*j+irow ].real=a[ (*lda)*(j-jcol)+i ].real;
222  A[ LDA*j+irow ].imag=a[ (*lda)*(j-jcol)+i ].imag;
223  }
224  }
225  }
226  cblas_zhbmv( CblasRowMajor, uplo, *n, *k, alpha, A, LDA, x, *incx,
227  beta, y, *incy );
228  free(A);
229  }
230  }
231  else if (*layout == TEST_COL_MJR)
232  cblas_zhbmv(CblasColMajor, uplo, *n, *k, alpha, a, *lda, x, *incx,
233  beta, y, *incy );
234  else
235  cblas_zhbmv(UNDEFINED, uplo, *n, *k, alpha, a, *lda, x, *incx,
236  beta, y, *incy );
237 }
238 
239 void F77_zhpmv(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha,
240  CBLAS_TEST_ZOMPLEX *ap, CBLAS_TEST_ZOMPLEX *x, int *incx,
241  CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy){
242 
243  CBLAS_TEST_ZOMPLEX *A, *AP;
244  int i,j,k,LDA;
245  CBLAS_UPLO uplo;
246 
247  get_uplo_type(uplow,&uplo);
248  if (*layout == TEST_ROW_MJR) {
249  if (uplo != CblasUpper && uplo != CblasLower )
250  cblas_zhpmv(CblasRowMajor, UNDEFINED, *n, alpha, ap, x, *incx,
251  beta, y, *incy);
252  else {
253  LDA = *n;
254  A = (CBLAS_TEST_ZOMPLEX* )malloc(LDA*LDA*sizeof(CBLAS_TEST_ZOMPLEX ));
255  AP = (CBLAS_TEST_ZOMPLEX* )malloc( (((LDA+1)*LDA)/2)*
256  sizeof( CBLAS_TEST_ZOMPLEX ));
257  if (uplo == CblasUpper) {
258  for( j=0, k=0; j<*n; j++ )
259  for( i=0; i<j+1; i++, k++ ) {
260  A[ LDA*i+j ].real=ap[ k ].real;
261  A[ LDA*i+j ].imag=ap[ k ].imag;
262  }
263  for( i=0, k=0; i<*n; i++ )
264  for( j=i; j<*n; j++, k++ ) {
265  AP[ k ].real=A[ LDA*i+j ].real;
266  AP[ k ].imag=A[ LDA*i+j ].imag;
267  }
268  }
269  else {
270  for( j=0, k=0; j<*n; j++ )
271  for( i=j; i<*n; i++, k++ ) {
272  A[ LDA*i+j ].real=ap[ k ].real;
273  A[ LDA*i+j ].imag=ap[ k ].imag;
274  }
275  for( i=0, k=0; i<*n; i++ )
276  for( j=0; j<i+1; j++, k++ ) {
277  AP[ k ].real=A[ LDA*i+j ].real;
278  AP[ k ].imag=A[ LDA*i+j ].imag;
279  }
280  }
281  cblas_zhpmv( CblasRowMajor, uplo, *n, alpha, AP, x, *incx, beta, y,
282  *incy );
283  free(A);
284  free(AP);
285  }
286  }
287  else if (*layout == TEST_COL_MJR)
288  cblas_zhpmv( CblasColMajor, uplo, *n, alpha, ap, x, *incx, beta, y,
289  *incy );
290  else
291  cblas_zhpmv( UNDEFINED, uplo, *n, alpha, ap, x, *incx, beta, y,
292  *incy );
293 }
294 
295 void F77_ztbmv(int *layout, char *uplow, char *transp, char *diagn,
296  int *n, int *k, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x,
297  int *incx) {
299  int irow, jcol, i, j, LDA;
300  CBLAS_TRANSPOSE trans;
301  CBLAS_UPLO uplo;
302  CBLAS_DIAG diag;
303 
304  get_transpose_type(transp,&trans);
305  get_uplo_type(uplow,&uplo);
306  get_diag_type(diagn,&diag);
307 
308  if (*layout == TEST_ROW_MJR) {
309  if (uplo != CblasUpper && uplo != CblasLower )
310  cblas_ztbmv(CblasRowMajor, UNDEFINED, trans, diag, *n, *k, a, *lda,
311  x, *incx);
312  else {
313  LDA = *k+2;
314  A=(CBLAS_TEST_ZOMPLEX *)malloc((*n+*k)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
315  if (uplo == CblasUpper) {
316  for( i=0; i<*k; i++ ){
317  irow=*k-i;
318  jcol=(*k)-i;
319  for( j=jcol; j<*n; j++ ) {
320  A[ LDA*(j-jcol)+irow ].real=a[ (*lda)*j+i ].real;
321  A[ LDA*(j-jcol)+irow ].imag=a[ (*lda)*j+i ].imag;
322  }
323  }
324  i=*k;
325  irow=*k-i;
326  for( j=0; j<*n; j++ ) {
327  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
328  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
329  }
330  }
331  else {
332  i=0;
333  irow=*k-i;
334  for( j=0; j<*n; j++ ) {
335  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
336  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
337  }
338  for( i=1; i<*k+1; i++ ){
339  irow=*k-i;
340  jcol=i;
341  for( j=jcol; j<(*n+*k); j++ ) {
342  A[ LDA*j+irow ].real=a[ (*lda)*(j-jcol)+i ].real;
343  A[ LDA*j+irow ].imag=a[ (*lda)*(j-jcol)+i ].imag;
344  }
345  }
346  }
347  cblas_ztbmv(CblasRowMajor, uplo, trans, diag, *n, *k, A, LDA, x,
348  *incx);
349  free(A);
350  }
351  }
352  else if (*layout == TEST_COL_MJR)
353  cblas_ztbmv(CblasColMajor, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
354  else
355  cblas_ztbmv(UNDEFINED, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
356 }
357 
358 void F77_ztbsv(int *layout, char *uplow, char *transp, char *diagn,
359  int *n, int *k, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x,
360  int *incx) {
361 
363  int irow, jcol, i, j, LDA;
364  CBLAS_TRANSPOSE trans;
365  CBLAS_UPLO uplo;
366  CBLAS_DIAG diag;
367 
368  get_transpose_type(transp,&trans);
369  get_uplo_type(uplow,&uplo);
370  get_diag_type(diagn,&diag);
371 
372  if (*layout == TEST_ROW_MJR) {
373  if (uplo != CblasUpper && uplo != CblasLower )
374  cblas_ztbsv(CblasRowMajor, UNDEFINED, trans, diag, *n, *k, a, *lda, x,
375  *incx);
376  else {
377  LDA = *k+2;
378  A=(CBLAS_TEST_ZOMPLEX*)malloc((*n+*k)*LDA*sizeof(CBLAS_TEST_ZOMPLEX ));
379  if (uplo == CblasUpper) {
380  for( i=0; i<*k; i++ ){
381  irow=*k-i;
382  jcol=(*k)-i;
383  for( j=jcol; j<*n; j++ ) {
384  A[ LDA*(j-jcol)+irow ].real=a[ (*lda)*j+i ].real;
385  A[ LDA*(j-jcol)+irow ].imag=a[ (*lda)*j+i ].imag;
386  }
387  }
388  i=*k;
389  irow=*k-i;
390  for( j=0; j<*n; j++ ) {
391  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
392  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
393  }
394  }
395  else {
396  i=0;
397  irow=*k-i;
398  for( j=0; j<*n; j++ ) {
399  A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
400  A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
401  }
402  for( i=1; i<*k+1; i++ ){
403  irow=*k-i;
404  jcol=i;
405  for( j=jcol; j<(*n+*k); j++ ) {
406  A[ LDA*j+irow ].real=a[ (*lda)*(j-jcol)+i ].real;
407  A[ LDA*j+irow ].imag=a[ (*lda)*(j-jcol)+i ].imag;
408  }
409  }
410  }
411  cblas_ztbsv(CblasRowMajor, uplo, trans, diag, *n, *k, A, LDA,
412  x, *incx);
413  free(A);
414  }
415  }
416  else if (*layout == TEST_COL_MJR)
417  cblas_ztbsv(CblasColMajor, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
418  else
419  cblas_ztbsv(UNDEFINED, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
420 }
421 
422 void F77_ztpmv(int *layout, char *uplow, char *transp, char *diagn,
423  int *n, CBLAS_TEST_ZOMPLEX *ap, CBLAS_TEST_ZOMPLEX *x, int *incx) {
424  CBLAS_TEST_ZOMPLEX *A, *AP;
425  int i, j, k, LDA;
426  CBLAS_TRANSPOSE trans;
427  CBLAS_UPLO uplo;
428  CBLAS_DIAG diag;
429 
430  get_transpose_type(transp,&trans);
431  get_uplo_type(uplow,&uplo);
432  get_diag_type(diagn,&diag);
433 
434  if (*layout == TEST_ROW_MJR) {
435  if (uplo != CblasUpper && uplo != CblasLower )
436  cblas_ztpmv( CblasRowMajor, UNDEFINED, trans, diag, *n, ap, x, *incx );
437  else {
438  LDA = *n;
439  A=(CBLAS_TEST_ZOMPLEX*)malloc(LDA*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
440  AP=(CBLAS_TEST_ZOMPLEX*)malloc((((LDA+1)*LDA)/2)*
441  sizeof(CBLAS_TEST_ZOMPLEX));
442  if (uplo == CblasUpper) {
443  for( j=0, k=0; j<*n; j++ )
444  for( i=0; i<j+1; i++, k++ ) {
445  A[ LDA*i+j ].real=ap[ k ].real;
446  A[ LDA*i+j ].imag=ap[ k ].imag;
447  }
448  for( i=0, k=0; i<*n; i++ )
449  for( j=i; j<*n; j++, k++ ) {
450  AP[ k ].real=A[ LDA*i+j ].real;
451  AP[ k ].imag=A[ LDA*i+j ].imag;
452  }
453  }
454  else {
455  for( j=0, k=0; j<*n; j++ )
456  for( i=j; i<*n; i++, k++ ) {
457  A[ LDA*i+j ].real=ap[ k ].real;
458  A[ LDA*i+j ].imag=ap[ k ].imag;
459  }
460  for( i=0, k=0; i<*n; i++ )
461  for( j=0; j<i+1; j++, k++ ) {
462  AP[ k ].real=A[ LDA*i+j ].real;
463  AP[ k ].imag=A[ LDA*i+j ].imag;
464  }
465  }
466  cblas_ztpmv( CblasRowMajor, uplo, trans, diag, *n, AP, x, *incx );
467  free(A);
468  free(AP);
469  }
470  }
471  else if (*layout == TEST_COL_MJR)
472  cblas_ztpmv( CblasColMajor, uplo, trans, diag, *n, ap, x, *incx );
473  else
474  cblas_ztpmv( UNDEFINED, uplo, trans, diag, *n, ap, x, *incx );
475 }
476 
477 void F77_ztpsv(int *layout, char *uplow, char *transp, char *diagn,
478  int *n, CBLAS_TEST_ZOMPLEX *ap, CBLAS_TEST_ZOMPLEX *x, int *incx) {
479  CBLAS_TEST_ZOMPLEX *A, *AP;
480  int i, j, k, LDA;
481  CBLAS_TRANSPOSE trans;
482  CBLAS_UPLO uplo;
483  CBLAS_DIAG diag;
484 
485  get_transpose_type(transp,&trans);
486  get_uplo_type(uplow,&uplo);
487  get_diag_type(diagn,&diag);
488 
489  if (*layout == TEST_ROW_MJR) {
490  if (uplo != CblasUpper && uplo != CblasLower )
491  cblas_ztpsv( CblasRowMajor, UNDEFINED, trans, diag, *n, ap, x, *incx );
492  else {
493  LDA = *n;
494  A=(CBLAS_TEST_ZOMPLEX*)malloc(LDA*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
495  AP=(CBLAS_TEST_ZOMPLEX*)malloc((((LDA+1)*LDA)/2)*
496  sizeof(CBLAS_TEST_ZOMPLEX));
497  if (uplo == CblasUpper) {
498  for( j=0, k=0; j<*n; j++ )
499  for( i=0; i<j+1; i++, k++ ) {
500  A[ LDA*i+j ].real=ap[ k ].real;
501  A[ LDA*i+j ].imag=ap[ k ].imag;
502  }
503  for( i=0, k=0; i<*n; i++ )
504  for( j=i; j<*n; j++, k++ ) {
505  AP[ k ].real=A[ LDA*i+j ].real;
506  AP[ k ].imag=A[ LDA*i+j ].imag;
507  }
508  }
509  else {
510  for( j=0, k=0; j<*n; j++ )
511  for( i=j; i<*n; i++, k++ ) {
512  A[ LDA*i+j ].real=ap[ k ].real;
513  A[ LDA*i+j ].imag=ap[ k ].imag;
514  }
515  for( i=0, k=0; i<*n; i++ )
516  for( j=0; j<i+1; j++, k++ ) {
517  AP[ k ].real=A[ LDA*i+j ].real;
518  AP[ k ].imag=A[ LDA*i+j ].imag;
519  }
520  }
521  cblas_ztpsv( CblasRowMajor, uplo, trans, diag, *n, AP, x, *incx );
522  free(A);
523  free(AP);
524  }
525  }
526  else if (*layout == TEST_COL_MJR)
527  cblas_ztpsv( CblasColMajor, uplo, trans, diag, *n, ap, x, *incx );
528  else
529  cblas_ztpsv( UNDEFINED, uplo, trans, diag, *n, ap, x, *incx );
530 }
531 
532 void F77_ztrmv(int *layout, char *uplow, char *transp, char *diagn,
533  int *n, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x,
534  int *incx) {
536  int i,j,LDA;
537  CBLAS_TRANSPOSE trans;
538  CBLAS_UPLO uplo;
539  CBLAS_DIAG diag;
540 
541  get_transpose_type(transp,&trans);
542  get_uplo_type(uplow,&uplo);
543  get_diag_type(diagn,&diag);
544 
545  if (*layout == TEST_ROW_MJR) {
546  LDA=*n+1;
547  A=(CBLAS_TEST_ZOMPLEX*)malloc((*n)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
548  for( i=0; i<*n; i++ )
549  for( j=0; j<*n; j++ ) {
550  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
551  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
552  }
553  cblas_ztrmv(CblasRowMajor, uplo, trans, diag, *n, A, LDA, x, *incx);
554  free(A);
555  }
556  else if (*layout == TEST_COL_MJR)
557  cblas_ztrmv(CblasColMajor, uplo, trans, diag, *n, a, *lda, x, *incx);
558  else
559  cblas_ztrmv(UNDEFINED, uplo, trans, diag, *n, a, *lda, x, *incx);
560 }
561 void F77_ztrsv(int *layout, char *uplow, char *transp, char *diagn,
562  int *n, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x,
563  int *incx) {
565  int i,j,LDA;
566  CBLAS_TRANSPOSE trans;
567  CBLAS_UPLO uplo;
568  CBLAS_DIAG diag;
569 
570  get_transpose_type(transp,&trans);
571  get_uplo_type(uplow,&uplo);
572  get_diag_type(diagn,&diag);
573 
574  if (*layout == TEST_ROW_MJR) {
575  LDA = *n+1;
576  A =(CBLAS_TEST_ZOMPLEX* )malloc((*n)*LDA*sizeof(CBLAS_TEST_ZOMPLEX ) );
577  for( i=0; i<*n; i++ )
578  for( j=0; j<*n; j++ ) {
579  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
580  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
581  }
582  cblas_ztrsv(CblasRowMajor, uplo, trans, diag, *n, A, LDA, x, *incx );
583  free(A);
584  }
585  else if (*layout == TEST_COL_MJR)
586  cblas_ztrsv(CblasColMajor, uplo, trans, diag, *n, a, *lda, x, *incx );
587  else
588  cblas_ztrsv(UNDEFINED, uplo, trans, diag, *n, a, *lda, x, *incx );
589 }
590 
591 void F77_zhpr(int *layout, char *uplow, int *n, double *alpha,
592  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *ap) {
593  CBLAS_TEST_ZOMPLEX *A, *AP;
594  int i,j,k,LDA;
595  CBLAS_UPLO uplo;
596 
597  get_uplo_type(uplow,&uplo);
598 
599  if (*layout == TEST_ROW_MJR) {
600  if (uplo != CblasUpper && uplo != CblasLower )
601  cblas_zhpr(CblasRowMajor, UNDEFINED, *n, *alpha, x, *incx, ap );
602  else {
603  LDA = *n;
604  A = (CBLAS_TEST_ZOMPLEX* )malloc(LDA*LDA*sizeof(CBLAS_TEST_ZOMPLEX ) );
605  AP = ( CBLAS_TEST_ZOMPLEX* )malloc( (((LDA+1)*LDA)/2)*
606  sizeof( CBLAS_TEST_ZOMPLEX ));
607  if (uplo == CblasUpper) {
608  for( j=0, k=0; j<*n; j++ )
609  for( i=0; i<j+1; i++, k++ ){
610  A[ LDA*i+j ].real=ap[ k ].real;
611  A[ LDA*i+j ].imag=ap[ k ].imag;
612  }
613  for( i=0, k=0; i<*n; i++ )
614  for( j=i; j<*n; j++, k++ ){
615  AP[ k ].real=A[ LDA*i+j ].real;
616  AP[ k ].imag=A[ LDA*i+j ].imag;
617  }
618  }
619  else {
620  for( j=0, k=0; j<*n; j++ )
621  for( i=j; i<*n; i++, k++ ){
622  A[ LDA*i+j ].real=ap[ k ].real;
623  A[ LDA*i+j ].imag=ap[ k ].imag;
624  }
625  for( i=0, k=0; i<*n; i++ )
626  for( j=0; j<i+1; j++, k++ ){
627  AP[ k ].real=A[ LDA*i+j ].real;
628  AP[ k ].imag=A[ LDA*i+j ].imag;
629  }
630  }
631  cblas_zhpr(CblasRowMajor, uplo, *n, *alpha, x, *incx, AP );
632  if (uplo == CblasUpper) {
633  for( i=0, k=0; i<*n; i++ )
634  for( j=i; j<*n; j++, k++ ){
635  A[ LDA*i+j ].real=AP[ k ].real;
636  A[ LDA*i+j ].imag=AP[ k ].imag;
637  }
638  for( j=0, k=0; j<*n; j++ )
639  for( i=0; i<j+1; i++, k++ ){
640  ap[ k ].real=A[ LDA*i+j ].real;
641  ap[ k ].imag=A[ LDA*i+j ].imag;
642  }
643  }
644  else {
645  for( i=0, k=0; i<*n; i++ )
646  for( j=0; j<i+1; j++, k++ ){
647  A[ LDA*i+j ].real=AP[ k ].real;
648  A[ LDA*i+j ].imag=AP[ k ].imag;
649  }
650  for( j=0, k=0; j<*n; j++ )
651  for( i=j; i<*n; i++, k++ ){
652  ap[ k ].real=A[ LDA*i+j ].real;
653  ap[ k ].imag=A[ LDA*i+j ].imag;
654  }
655  }
656  free(A);
657  free(AP);
658  }
659  }
660  else if (*layout == TEST_COL_MJR)
661  cblas_zhpr(CblasColMajor, uplo, *n, *alpha, x, *incx, ap );
662  else
663  cblas_zhpr(UNDEFINED, uplo, *n, *alpha, x, *incx, ap );
664 }
665 
666 void F77_zhpr2(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha,
667  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy,
668  CBLAS_TEST_ZOMPLEX *ap) {
669  CBLAS_TEST_ZOMPLEX *A, *AP;
670  int i,j,k,LDA;
671  CBLAS_UPLO uplo;
672 
673  get_uplo_type(uplow,&uplo);
674 
675  if (*layout == TEST_ROW_MJR) {
676  if (uplo != CblasUpper && uplo != CblasLower )
677  cblas_zhpr2( CblasRowMajor, UNDEFINED, *n, alpha, x, *incx, y,
678  *incy, ap );
679  else {
680  LDA = *n;
681  A=(CBLAS_TEST_ZOMPLEX*)malloc( LDA*LDA*sizeof(CBLAS_TEST_ZOMPLEX ) );
682  AP=(CBLAS_TEST_ZOMPLEX*)malloc( (((LDA+1)*LDA)/2)*
683  sizeof( CBLAS_TEST_ZOMPLEX ));
684  if (uplo == CblasUpper) {
685  for( j=0, k=0; j<*n; j++ )
686  for( i=0; i<j+1; i++, k++ ) {
687  A[ LDA*i+j ].real=ap[ k ].real;
688  A[ LDA*i+j ].imag=ap[ k ].imag;
689  }
690  for( i=0, k=0; i<*n; i++ )
691  for( j=i; j<*n; j++, k++ ) {
692  AP[ k ].real=A[ LDA*i+j ].real;
693  AP[ k ].imag=A[ LDA*i+j ].imag;
694  }
695  }
696  else {
697  for( j=0, k=0; j<*n; j++ )
698  for( i=j; i<*n; i++, k++ ) {
699  A[ LDA*i+j ].real=ap[ k ].real;
700  A[ LDA*i+j ].imag=ap[ k ].imag;
701  }
702  for( i=0, k=0; i<*n; i++ )
703  for( j=0; j<i+1; j++, k++ ) {
704  AP[ k ].real=A[ LDA*i+j ].real;
705  AP[ k ].imag=A[ LDA*i+j ].imag;
706  }
707  }
708  cblas_zhpr2( CblasRowMajor, uplo, *n, alpha, x, *incx, y, *incy, AP );
709  if (uplo == CblasUpper) {
710  for( i=0, k=0; i<*n; i++ )
711  for( j=i; j<*n; j++, k++ ) {
712  A[ LDA*i+j ].real=AP[ k ].real;
713  A[ LDA*i+j ].imag=AP[ k ].imag;
714  }
715  for( j=0, k=0; j<*n; j++ )
716  for( i=0; i<j+1; i++, k++ ) {
717  ap[ k ].real=A[ LDA*i+j ].real;
718  ap[ k ].imag=A[ LDA*i+j ].imag;
719  }
720  }
721  else {
722  for( i=0, k=0; i<*n; i++ )
723  for( j=0; j<i+1; j++, k++ ) {
724  A[ LDA*i+j ].real=AP[ k ].real;
725  A[ LDA*i+j ].imag=AP[ k ].imag;
726  }
727  for( j=0, k=0; j<*n; j++ )
728  for( i=j; i<*n; i++, k++ ) {
729  ap[ k ].real=A[ LDA*i+j ].real;
730  ap[ k ].imag=A[ LDA*i+j ].imag;
731  }
732  }
733  free(A);
734  free(AP);
735  }
736  }
737  else if (*layout == TEST_COL_MJR)
738  cblas_zhpr2( CblasColMajor, uplo, *n, alpha, x, *incx, y, *incy, ap );
739  else
740  cblas_zhpr2( UNDEFINED, uplo, *n, alpha, x, *incx, y, *incy, ap );
741 }
742 
743 void F77_zher(int *layout, char *uplow, int *n, double *alpha,
744  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *a, int *lda) {
746  int i,j,LDA;
747  CBLAS_UPLO uplo;
748 
749  get_uplo_type(uplow,&uplo);
750 
751  if (*layout == TEST_ROW_MJR) {
752  LDA = *n+1;
753  A=(CBLAS_TEST_ZOMPLEX*)malloc((*n)*LDA*sizeof( CBLAS_TEST_ZOMPLEX ));
754 
755  for( i=0; i<*n; i++ )
756  for( j=0; j<*n; j++ ) {
757  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
758  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
759  }
760 
761  cblas_zher(CblasRowMajor, uplo, *n, *alpha, x, *incx, A, LDA );
762  for( i=0; i<*n; i++ )
763  for( j=0; j<*n; j++ ) {
764  a[ (*lda)*j+i ].real=A[ LDA*i+j ].real;
765  a[ (*lda)*j+i ].imag=A[ LDA*i+j ].imag;
766  }
767  free(A);
768  }
769  else if (*layout == TEST_COL_MJR)
770  cblas_zher( CblasColMajor, uplo, *n, *alpha, x, *incx, a, *lda );
771  else
772  cblas_zher( UNDEFINED, uplo, *n, *alpha, x, *incx, a, *lda );
773 }
774 
775 void F77_zher2(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha,
776  CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy,
777  CBLAS_TEST_ZOMPLEX *a, int *lda) {
778 
780  int i,j,LDA;
781  CBLAS_UPLO uplo;
782 
783  get_uplo_type(uplow,&uplo);
784 
785  if (*layout == TEST_ROW_MJR) {
786  LDA = *n+1;
787  A= ( CBLAS_TEST_ZOMPLEX* )malloc((*n)*LDA*sizeof(CBLAS_TEST_ZOMPLEX ) );
788 
789  for( i=0; i<*n; i++ )
790  for( j=0; j<*n; j++ ) {
791  A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
792  A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
793  }
794 
795  cblas_zher2(CblasRowMajor, uplo, *n, alpha, x, *incx, y, *incy, A, LDA );
796  for( i=0; i<*n; i++ )
797  for( j=0; j<*n; j++ ) {
798  a[ (*lda)*j+i ].real=A[ LDA*i+j ].real;
799  a[ (*lda)*j+i ].imag=A[ LDA*i+j ].imag;
800  }
801  free(A);
802  }
803  else if (*layout == TEST_COL_MJR)
804  cblas_zher2( CblasColMajor, uplo, *n, alpha, x, *incx, y, *incy, a, *lda);
805  else
806  cblas_zher2( UNDEFINED, uplo, *n, alpha, x, *incx, y, *incy, a, *lda);
807 }
void cblas_zhbmv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const int K, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY)
Definition: cblas_zhbmv.c:12
void F77_zgeru(int *layout, int *m, int *n, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy, CBLAS_TEST_ZOMPLEX *a, int *lda)
Definition: c_zblas2.c:88
#define LDA
Definition: example_user.c:12
void cblas_zher(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const double alpha, const void *X, const int incX, void *A, const int lda)
Definition: cblas_zher.c:12
void F77_zhbmv(int *layout, char *uplow, int *n, int *k, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy)
Definition: c_zblas2.c:175
void cblas_zhpr2(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *Ap)
Definition: cblas_zhpr2.c:12
CBLAS_DIAG
Definition: cblas.h:22
void cblas_zhpr(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const double alpha, const void *X, const int incX, void *A)
Definition: cblas_zhpr.c:12
void F77_zgbmv(int *layout, char *transp, int *m, int *n, int *kl, int *ku, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy)
Definition: c_zblas2.c:41
void F77_ztrsv(int *layout, char *uplow, char *transp, char *diagn, int *n, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx)
Definition: c_zblas2.c:561
void F77_zhemv(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy)
Definition: c_zblas2.c:145
void F77_ztrmv(int *layout, char *uplow, char *transp, char *diagn, int *n, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx)
Definition: c_zblas2.c:532
#define UNDEFINED
Definition: cblas_test.h:19
void F77_ztbmv(int *layout, char *uplow, char *transp, char *diagn, int *n, int *k, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx)
Definition: c_zblas2.c:295
void F77_zgerc(int *layout, int *m, int *n, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy, CBLAS_TEST_ZOMPLEX *a, int *lda)
Definition: c_zblas2.c:117
void F77_ztbsv(int *layout, char *uplow, char *transp, char *diagn, int *n, int *k, CBLAS_TEST_ZOMPLEX *a, int *lda, CBLAS_TEST_ZOMPLEX *x, int *incx)
Definition: c_zblas2.c:358
void F77_zher(int *layout, char *uplow, int *n, double *alpha, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *a, int *lda)
Definition: c_zblas2.c:743
void cblas_ztrsv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX)
Definition: cblas_ztrsv.c:10
void cblas_zgemv(CBLAS_LAYOUT layout, CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY)
Definition: cblas_zgemv.c:12
void F77_zher2(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy, CBLAS_TEST_ZOMPLEX *a, int *lda)
Definition: c_zblas2.c:775
void F77_ztpmv(int *layout, char *uplow, char *transp, char *diagn, int *n, CBLAS_TEST_ZOMPLEX *ap, CBLAS_TEST_ZOMPLEX *x, int *incx)
Definition: c_zblas2.c:422
void cblas_zhemv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY)
Definition: cblas_zhemv.c:12
void get_diag_type(char *type, CBLAS_DIAG *diag)
Definition: auxiliary.c:25
void cblas_ztbmv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX)
Definition: cblas_ztbmv.c:10
void get_transpose_type(char *type, CBLAS_TRANSPOSE *trans)
Definition: auxiliary.c:8
void cblas_zher2(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda)
Definition: cblas_zher2.c:12
#define TEST_ROW_MJR
Definition: cblas_test.h:12
void cblas_ztpsv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX)
Definition: cblas_ztpsv.c:10
void cblas_zgeru(CBLAS_LAYOUT layout, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda)
Definition: cblas_zgeru.c:10
void cblas_ztrmv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX)
Definition: cblas_ztrmv.c:10
void cblas_zgerc(CBLAS_LAYOUT layout, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda)
Definition: cblas_zgerc.c:12
CBLAS_TRANSPOSE
Definition: cblas.h:20
void get_uplo_type(char *type, CBLAS_UPLO *uplo)
Definition: auxiliary.c:18
void F77_zhpr2(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy, CBLAS_TEST_ZOMPLEX *ap)
Definition: c_zblas2.c:666
void F77_zgemv(int *layout, char *transp, int *m, int *n, const void *alpha, CBLAS_TEST_ZOMPLEX *a, int *lda, const void *x, int *incx, const void *beta, void *y, int *incy)
Definition: c_zblas2.c:11
void cblas_ztpmv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX)
Definition: cblas_ztpmv.c:10
CBLAS_UPLO
Definition: cblas.h:21
void cblas_ztbsv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, CBLAS_TRANSPOSE TransA, CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX)
Definition: cblas_ztbsv.c:10
void F77_zhpr(int *layout, char *uplow, int *n, double *alpha, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *ap)
Definition: c_zblas2.c:591
#define TEST_COL_MJR
Definition: cblas_test.h:16
void cblas_zhpmv(CBLAS_LAYOUT layout, CBLAS_UPLO Uplo, const int N, const void *alpha, const void *Ap, const void *X, const int incX, const void *beta, void *Y, const int incY)
Definition: cblas_zhpmv.c:12
void F77_ztpsv(int *layout, char *uplow, char *transp, char *diagn, int *n, CBLAS_TEST_ZOMPLEX *ap, CBLAS_TEST_ZOMPLEX *x, int *incx)
Definition: c_zblas2.c:477
void cblas_zgbmv(CBLAS_LAYOUT layout, CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY)
Definition: cblas_zgbmv.c:12
void F77_zhpmv(int *layout, char *uplow, int *n, CBLAS_TEST_ZOMPLEX *alpha, CBLAS_TEST_ZOMPLEX *ap, CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *beta, CBLAS_TEST_ZOMPLEX *y, int *incy)
Definition: c_zblas2.c:239