← Back to branch summary

~ubuntu-branches/ubuntu/vivid/atlas/vivid

« back to all changes in this revision

Viewing changes to src/blas/level2/ATL_gpmv.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2002-04-13 10:07:52 UTC
  • Revision ID: james.westby@ubuntu.com-20020413100752-va9zm0rd4gpurdkq
Tags: upstream-3.2.1ln
Import upstream version 3.2.1ln

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/blas/level2/ATL_gpmv.c
 
1
/* ---------------------------------------------------------------------
 
2
 *
 
3
 * -- Automatically Tuned Linear Algebra Software (ATLAS)
 
4
 *    (C) Copyright 2000 All Rights Reserved
 
5
 *
 
6
 * -- ATLAS routine -- Version 3.0 -- April 1, 2000
 
7
 *
 
8
 * -- Suggestions,  comments,  bugs reports should be sent to the follo-
 
9
 *    wing e-mail address: atlas@cs.utk.edu
 
10
 *
 
11
 * Author         : Antoine P. Petitet
 
12
 * Contributor(s) : R. Clint Whaley
 
13
 * University of Tennessee - Innovative Computing Laboratory
 
14
 * Knoxville TN, 37996-1301, USA.
 
15
 *
 
16
 * ---------------------------------------------------------------------
 
17
 *
 
18
 * -- Copyright notice and Licensing terms:
 
19
 *
 
20
 *  Redistribution  and  use in  source and binary forms, with or without
 
21
 *  modification, are  permitted provided  that the following  conditions
 
22
 *  are met:
 
23
 *
 
24
 * 1. Redistributions  of  source  code  must retain the above copyright
 
25
 *    notice, this list of conditions and the following disclaimer.
 
26
 * 2. Redistributions in binary form must reproduce  the above copyright
 
27
 *    notice,  this list of conditions, and the  following disclaimer in
 
28
 *    the documentation and/or other materials provided with the distri-
 
29
 *    bution.
 
30
 * 3. The name of the University,  the ATLAS group,  or the names of its
 
31
 *    contributors  may not be used to endorse or promote products deri-
 
32
 *    ved from this software without specific written permission.
 
33
 *
 
34
 * -- Disclaimer:
 
35
 *
 
36
 * THIS  SOFTWARE  IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
37
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,  INCLUDING,  BUT NOT
 
38
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
39
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY
 
40
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,  INDIRECT, INCIDENTAL, SPE-
 
41
 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 
42
 * TO,  PROCUREMENT  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 
43
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEO-
 
44
 * RY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  (IN-
 
45
 * CLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
46
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
47
 *
 
48
 * ---------------------------------------------------------------------
 
49
 */
 
50
/*
 
51
 * Include files
 
52
 */
 
53
#include "atlas_misc.h"
 
54
#include "atlas_level1.h"
 
55
#include "atlas_kernel2.h"
 
56
#include "atlas_lvl2.h"
 
57
#include "atlas_mv.h"
 
58
#include "atlas_r1.h"
 
59
 
 
60
#include "atlas_reflvl2.h"          /* temporary for building purposes */
 
61
#include "atlas_reflevel2.h"        /* used for gbmv, gpmv and gpr.    */
 
62
 
 
63
/* #define USEKERN */
 
64
void Mjoin( PATL, gpmv )
 
65
(
 
66
   const enum ATLAS_UPLO      UPLO,
 
67
   const enum ATLAS_TRANS     TRANS,
 
68
   const int                  M,
 
69
   const int                  N,
 
70
   const SCALAR               ALPHA,
 
71
   const TYPE                 * A,
 
72
   const int                  LDA,
 
73
   const TYPE                 * X,
 
74
   const int                  INCX,
 
75
   const SCALAR               BETA,
 
76
   TYPE                       * Y,
 
77
   const int                  INCY
 
78
)
 
79
{
 
80
/*
 
81
 * .. Local Variables ..
 
82
 */
 
83
/* ..
 
84
 * .. Executable Statements ..
 
85
 *
 
86
 */
 
87
   if( ( M == 0 ) || ( N == 0 ) ||
 
88
       ( ( SCALAR_IS_ZERO( ALPHA ) ) && ( SCALAR_IS_ONE( BETA ) ) ) ) return;
 
89
 
 
90
   if( SCALAR_IS_ZERO( ALPHA ) )
 
91
   {
 
92
      if( !( SCALAR_IS_ONE( BETA ) ) ) Mjoin( PATL, scal )( M, BETA, Y, INCY );
 
93
      return;
 
94
   }
 
95
 
 
96
   Mjoin( PATL, refgpmv )( UPLO, TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA,
 
97
                           Y, INCY );
 
98
/*
 
99
 * End of Mjoin( PATL, gpmv )
 
100
 */
 
101
}
 
102
 
 
103
#ifndef USEKERN
 
104
void Mjoin( PATL, gpmvLN_a1_x1_b0_y1 )
 
105
(
 
106
   const int                  M,
 
107
   const int                  N,
 
108
   const SCALAR               ALPHA,
 
109
   const TYPE                 * A,
 
110
   const int                  LDA,
 
111
   const TYPE                 * X,
 
112
   const int                  INCX,
 
113
   const SCALAR               BETA,
 
114
   TYPE                       * Y,
 
115
   const int                  INCY
 
116
)
 
117
{
 
118
#ifdef TREAL
 
119
#define    one                ATL_rone
 
120
#define    zero               ATL_rzero
 
121
#else
 
122
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
123
                              zero[2] = { ATL_rzero, ATL_rzero };
 
124
#endif
 
125
   Mjoin( PATL, gpmv )( AtlasLower, AtlasNoTrans, M, N, one, A, LDA,
 
126
                        X, 1, zero, Y, 1 );
 
127
}
 
128
#endif
 
129
 
 
130
void Mjoin( PATL, gpmvLT_a1_x1_b0_y1 )
 
131
(
 
132
   const int                  M,
 
133
   const int                  N,
 
134
   const SCALAR               ALPHA,
 
135
   const TYPE                 * A,
 
136
   const int                  LDA,
 
137
   const TYPE                 * X,
 
138
   const int                  INCX,
 
139
   const SCALAR               BETA,
 
140
   TYPE                       * Y,
 
141
   const int                  INCY
 
142
)
 
143
{
 
144
#ifdef TREAL
 
145
#define    one                ATL_rone
 
146
#define    zero               ATL_rzero
 
147
#else
 
148
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
149
                              zero[2] = { ATL_rzero, ATL_rzero };
 
150
#endif
 
151
   Mjoin( PATL, gpmv )( AtlasLower, AtlasTrans, M, N, one, A, LDA, X, 1,
 
152
                        zero, Y, 1 );
 
153
}
 
154
 
 
155
#ifdef TCPLX
 
156
void Mjoin( PATL, gpmvLC_a1_x1_b0_y1 )
 
157
(
 
158
   const int                  M,
 
159
   const int                  N,
 
160
   const SCALAR               ALPHA,
 
161
   const TYPE                 * A,
 
162
   const int                  LDA,
 
163
   const TYPE                 * X,
 
164
   const int                  INCX,
 
165
   const SCALAR               BETA,
 
166
   TYPE                       * Y,
 
167
   const int                  INCY
 
168
)
 
169
{
 
170
#ifdef TREAL
 
171
#define    one                ATL_rone
 
172
#define    zero               ATL_rzero
 
173
#else
 
174
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
175
                              zero[2] = { ATL_rzero, ATL_rzero };
 
176
#endif
 
177
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
178
                        zero, Y, 1 );
 
179
}
 
180
 
 
181
void Mjoin( PATL, gpmvLNc_a1_x1_b0_y1 )
 
182
(
 
183
   const int                  M,
 
184
   const int                  N,
 
185
   const SCALAR               ALPHA,
 
186
   const TYPE                 * A,
 
187
   const int                  LDA,
 
188
   const TYPE                 * X,
 
189
   const int                  INCX,
 
190
   const SCALAR               BETA,
 
191
   TYPE                       * Y,
 
192
   const int                  INCY
 
193
)
 
194
{
 
195
#ifdef TREAL
 
196
#define    one                ATL_rone
 
197
#define    zero               ATL_rzero
 
198
#else
 
199
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
200
                              zero[2] = { ATL_rzero, ATL_rzero };
 
201
#endif
 
202
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConj, M, N, one, A, LDA, X, 1,
 
203
                        zero, Y, 1 );
 
204
}
 
205
 
 
206
#endif
 
207
 
 
208
#ifdef TCPLX
 
209
#ifndef USEKERN
 
210
void Mjoin( PATL, gpmvLN_a1_x1_bXi0_y1 )
 
211
(
 
212
   const int                  M,
 
213
   const int                  N,
 
214
   const SCALAR               ALPHA,
 
215
   const TYPE                 * A,
 
216
   const int                  LDA,
 
217
   const TYPE                 * X,
 
218
   const int                  INCX,
 
219
   const SCALAR               BETA,
 
220
   TYPE                       * Y,
 
221
   const int                  INCY
 
222
)
 
223
{
 
224
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
225
   TYPE                       beta[2];
 
226
 
 
227
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
228
   Mjoin( PATL, gpmv )( AtlasLower, AtlasNoTrans, M, N, one, A, LDA, X, 1,
 
229
                        beta, Y, 1 );
 
230
}
 
231
#endif
 
232
 
 
233
void Mjoin( PATL, gpmvLT_a1_x1_bXi0_y1 )
 
234
(
 
235
   const int                  M,
 
236
   const int                  N,
 
237
   const SCALAR               ALPHA,
 
238
   const TYPE                 * A,
 
239
   const int                  LDA,
 
240
   const TYPE                 * X,
 
241
   const int                  INCX,
 
242
   const SCALAR               BETA,
 
243
   TYPE                       * Y,
 
244
   const int                  INCY
 
245
)
 
246
{
 
247
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
248
   TYPE                       beta[2];
 
249
 
 
250
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
251
   Mjoin( PATL, gpmv )( AtlasLower, AtlasTrans, M, N, one, A, LDA, X, 1,
 
252
                        beta, Y, 1 );
 
253
}
 
254
 
 
255
void Mjoin( PATL, gpmvLC_a1_x1_bXi0_y1 )
 
256
(
 
257
   const int                  M,
 
258
   const int                  N,
 
259
   const SCALAR               ALPHA,
 
260
   const TYPE                 * A,
 
261
   const int                  LDA,
 
262
   const TYPE                 * X,
 
263
   const int                  INCX,
 
264
   const SCALAR               BETA,
 
265
   TYPE                       * Y,
 
266
   const int                  INCY
 
267
)
 
268
{
 
269
   const TYPE                 one [2] = { ATL_rone, ATL_rzero };
 
270
   TYPE                       beta[2];
 
271
 
 
272
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
273
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
274
                        beta, Y, 1 );
 
275
}
 
276
 
 
277
void Mjoin( PATL, gpmvLNc_a1_x1_bXi0_y1 )
 
278
(
 
279
   const int                  M,
 
280
   const int                  N,
 
281
   const SCALAR               ALPHA,
 
282
   const TYPE                 * A,
 
283
   const int                  LDA,
 
284
   const TYPE                 * X,
 
285
   const int                  INCX,
 
286
   const SCALAR               BETA,
 
287
   TYPE                       * Y,
 
288
   const int                  INCY
 
289
)
 
290
{
 
291
   const TYPE                 one [2] = { ATL_rone, ATL_rzero };
 
292
   TYPE                       beta[2];
 
293
 
 
294
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
295
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConj, M, N, one, A, LDA, X, 1,
 
296
                        beta, Y, 1 );
 
297
}
 
298
 
 
299
#endif
 
300
 
 
301
#ifndef USEKERN
 
302
void Mjoin( PATL, gpmvLN_a1_x1_b1_y1 )
 
303
(
 
304
   const int                  M,
 
305
   const int                  N,
 
306
   const SCALAR               ALPHA,
 
307
   const TYPE                 * A,
 
308
   const int                  LDA,
 
309
   const TYPE                 * X,
 
310
   const int                  INCX,
 
311
   const SCALAR               BETA,
 
312
   TYPE                       * Y,
 
313
   const int                  INCY
 
314
)
 
315
{
 
316
#ifdef TREAL
 
317
#define    one                ATL_rone
 
318
#else
 
319
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
320
#endif
 
321
   Mjoin( PATL, gpmv )( AtlasLower, AtlasNoTrans, M, N, one, A, LDA, X, 1,
 
322
                        one, Y, 1 );
 
323
}
 
324
#endif
 
325
 
 
326
void Mjoin( PATL, gpmvLT_a1_x1_b1_y1 )
 
327
(
 
328
   const int                  M,
 
329
   const int                  N,
 
330
   const SCALAR               ALPHA,
 
331
   const TYPE                 * A,
 
332
   const int                  LDA,
 
333
   const TYPE                 * X,
 
334
   const int                  INCX,
 
335
   const SCALAR               BETA,
 
336
   TYPE                       * Y,
 
337
   const int                  INCY
 
338
)
 
339
{
 
340
#ifdef TREAL
 
341
#define    one                ATL_rone
 
342
#else
 
343
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
344
#endif
 
345
   Mjoin( PATL, gpmv )( AtlasLower, AtlasTrans, M, N, one, A, LDA, X, 1,
 
346
                        one, Y, 1 );
 
347
}
 
348
 
 
349
#ifdef TCPLX
 
350
void Mjoin( PATL, gpmvLC_a1_x1_b1_y1 )
 
351
(
 
352
   const int                  M,
 
353
   const int                  N,
 
354
   const SCALAR               ALPHA,
 
355
   const TYPE                 * A,
 
356
   const int                  LDA,
 
357
   const TYPE                 * X,
 
358
   const int                  INCX,
 
359
   const SCALAR               BETA,
 
360
   TYPE                       * Y,
 
361
   const int                  INCY
 
362
)
 
363
{
 
364
#ifdef TREAL
 
365
#define    one                ATL_rone
 
366
#else
 
367
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
368
#endif
 
369
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
370
                        one, Y, 1 );
 
371
}
 
372
 
 
373
void Mjoin( PATL, gpmvLNc_a1_x1_b1_y1 )
 
374
(
 
375
   const int                  M,
 
376
   const int                  N,
 
377
   const SCALAR               ALPHA,
 
378
   const TYPE                 * A,
 
379
   const int                  LDA,
 
380
   const TYPE                 * X,
 
381
   const int                  INCX,
 
382
   const SCALAR               BETA,
 
383
   TYPE                       * Y,
 
384
   const int                  INCY
 
385
)
 
386
{
 
387
#ifdef TREAL
 
388
#define    one                ATL_rone
 
389
#else
 
390
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
391
#endif
 
392
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConj, M, N, one, A, LDA, X, 1,
 
393
                        one, Y, 1 );
 
394
}
 
395
 
 
396
#endif
 
397
 
 
398
#ifndef USEKERN
 
399
void Mjoin( PATL, gpmvLN_a1_x1_bX_y1  )
 
400
(
 
401
   const int                  M,
 
402
   const int                  N,
 
403
   const SCALAR               ALPHA,
 
404
   const TYPE                 * A,
 
405
   const int                  LDA,
 
406
   const TYPE                 * X,
 
407
   const int                  INCX,
 
408
   const SCALAR               BETA,
 
409
   TYPE                       * Y,
 
410
   const int                  INCY
 
411
)
 
412
{
 
413
#ifdef TREAL
 
414
#define    one                ATL_rone
 
415
#else
 
416
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
417
#endif
 
418
   Mjoin( PATL, gpmv )( AtlasLower, AtlasNoTrans, M, N, one, A, LDA, X, 1,
 
419
                        BETA, Y, 1 );
 
420
}
 
421
#endif
 
422
 
 
423
void Mjoin( PATL, gpmvLT_a1_x1_bX_y1 )
 
424
(
 
425
   const int                  M,
 
426
   const int                  N,
 
427
   const SCALAR               ALPHA,
 
428
   const TYPE                 * A,
 
429
   const int                  LDA,
 
430
   const TYPE                 * X,
 
431
   const int                  INCX,
 
432
   const SCALAR               BETA,
 
433
   TYPE                       * Y,
 
434
   const int                  INCY
 
435
)
 
436
{
 
437
#ifdef TREAL
 
438
#define    one                ATL_rone
 
439
#else
 
440
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
441
#endif
 
442
   Mjoin( PATL, gpmv )( AtlasLower, AtlasTrans, M, N, one, A, LDA, X, 1,
 
443
                        BETA, Y, 1 );
 
444
}
 
445
 
 
446
#ifdef TCPLX
 
447
 
 
448
void Mjoin( PATL, gpmvLC_a1_x1_bX_y1 )
 
449
(
 
450
   const int                  M,
 
451
   const int                  N,
 
452
   const SCALAR               ALPHA,
 
453
   const TYPE                 * A,
 
454
   const int                  LDA,
 
455
   const TYPE                 * X,
 
456
   const int                  INCX,
 
457
   const SCALAR               BETA,
 
458
   TYPE                       * Y,
 
459
   const int                  INCY
 
460
)
 
461
{
 
462
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
463
 
 
464
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
465
                        BETA, Y, 1 );
 
466
}
 
467
 
 
468
void Mjoin( PATL, gpmvLNc_a1_x1_bX_y1 )
 
469
(
 
470
   const int                  M,
 
471
   const int                  N,
 
472
   const SCALAR               ALPHA,
 
473
   const TYPE                 * A,
 
474
   const int                  LDA,
 
475
   const TYPE                 * X,
 
476
   const int                  INCX,
 
477
   const SCALAR               BETA,
 
478
   TYPE                       * Y,
 
479
   const int                  INCY
 
480
)
 
481
{
 
482
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
483
 
 
484
   Mjoin( PATL, gpmv )( AtlasLower, AtlasConj, M, N, one, A, LDA, X, 1,
 
485
                        BETA, Y, 1 );
 
486
}
 
487
 
 
488
#endif
 
489
 
 
490
#ifndef USEKERN
 
491
void Mjoin( PATL, gpmvUN_a1_x1_b0_y1 )
 
492
(
 
493
   const int                  M,
 
494
   const int                  N,
 
495
   const SCALAR               ALPHA,
 
496
   const TYPE                 * A,
 
497
   const int                  LDA,
 
498
   const TYPE                 * X,
 
499
   const int                  INCX,
 
500
   const SCALAR               BETA,
 
501
   TYPE                       * Y,
 
502
   const int                  INCY
 
503
)
 
504
{
 
505
#ifdef TREAL
 
506
#define    one                ATL_rone
 
507
#define    zero               ATL_rzero
 
508
#else
 
509
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
510
                              zero[2] = { ATL_rzero, ATL_rzero };
 
511
#endif
 
512
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasNoTrans, M, N, one, A, LDA,
 
513
                        X, 1, zero, Y, 1 );
 
514
}
 
515
#endif
 
516
 
 
517
void Mjoin( PATL, gpmvUT_a1_x1_b0_y1 )
 
518
(
 
519
   const int                  M,
 
520
   const int                  N,
 
521
   const SCALAR               ALPHA,
 
522
   const TYPE                 * A,
 
523
   const int                  LDA,
 
524
   const TYPE                 * X,
 
525
   const int                  INCX,
 
526
   const SCALAR               BETA,
 
527
   TYPE                       * Y,
 
528
   const int                  INCY
 
529
)
 
530
{
 
531
#ifdef TREAL
 
532
#define    one                ATL_rone
 
533
#define    zero               ATL_rzero
 
534
#else
 
535
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
536
                              zero[2] = { ATL_rzero, ATL_rzero };
 
537
#endif
 
538
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasTrans, M, N, one, A, LDA, X, 1,
 
539
                        zero, Y, 1 );
 
540
}
 
541
 
 
542
#ifdef TCPLX
 
543
void Mjoin( PATL, gpmvUC_a1_x1_b0_y1 )
 
544
(
 
545
   const int                  M,
 
546
   const int                  N,
 
547
   const SCALAR               ALPHA,
 
548
   const TYPE                 * A,
 
549
   const int                  LDA,
 
550
   const TYPE                 * X,
 
551
   const int                  INCX,
 
552
   const SCALAR               BETA,
 
553
   TYPE                       * Y,
 
554
   const int                  INCY
 
555
)
 
556
{
 
557
#ifdef TREAL
 
558
#define    one                ATL_rone
 
559
#define    zero               ATL_rzero
 
560
#else
 
561
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
562
                              zero[2] = { ATL_rzero, ATL_rzero };
 
563
#endif
 
564
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
565
                        zero, Y, 1 );
 
566
}
 
567
 
 
568
void Mjoin( PATL, gpmvUNc_a1_x1_b0_y1 )
 
569
(
 
570
   const int                  M,
 
571
   const int                  N,
 
572
   const SCALAR               ALPHA,
 
573
   const TYPE                 * A,
 
574
   const int                  LDA,
 
575
   const TYPE                 * X,
 
576
   const int                  INCX,
 
577
   const SCALAR               BETA,
 
578
   TYPE                       * Y,
 
579
   const int                  INCY
 
580
)
 
581
{
 
582
#ifdef TREAL
 
583
#define    one                ATL_rone
 
584
#define    zero               ATL_rzero
 
585
#else
 
586
   const TYPE                 one [2] = { ATL_rone,  ATL_rzero },
 
587
                              zero[2] = { ATL_rzero, ATL_rzero };
 
588
#endif
 
589
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConj, M, N, one, A, LDA, X, 1,
 
590
                        zero, Y, 1 );
 
591
}
 
592
 
 
593
#endif
 
594
 
 
595
#ifdef TCPLX
 
596
#ifndef USEKERN
 
597
void Mjoin( PATL, gpmvUN_a1_x1_bXi0_y1 )
 
598
(
 
599
   const int                  M,
 
600
   const int                  N,
 
601
   const SCALAR               ALPHA,
 
602
   const TYPE                 * A,
 
603
   const int                  LDA,
 
604
   const TYPE                 * X,
 
605
   const int                  INCX,
 
606
   const SCALAR               BETA,
 
607
   TYPE                       * Y,
 
608
   const int                  INCY
 
609
)
 
610
{
 
611
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
612
   TYPE                       beta[2];
 
613
 
 
614
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
615
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasNoTrans, M, N, one, A, LDA, X, 1,
 
616
                        beta, Y, 1 );
 
617
}
 
618
#endif
 
619
 
 
620
void Mjoin( PATL, gpmvUT_a1_x1_bXi0_y1 )
 
621
(
 
622
   const int                  M,
 
623
   const int                  N,
 
624
   const SCALAR               ALPHA,
 
625
   const TYPE                 * A,
 
626
   const int                  LDA,
 
627
   const TYPE                 * X,
 
628
   const int                  INCX,
 
629
   const SCALAR               BETA,
 
630
   TYPE                       * Y,
 
631
   const int                  INCY
 
632
)
 
633
{
 
634
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
635
   TYPE                       beta[2];
 
636
 
 
637
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
638
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasTrans, M, N, one, A, LDA, X, 1,
 
639
                        beta, Y, 1 );
 
640
}
 
641
 
 
642
void Mjoin( PATL, gpmvUC_a1_x1_bXi0_y1 )
 
643
(
 
644
   const int                  M,
 
645
   const int                  N,
 
646
   const SCALAR               ALPHA,
 
647
   const TYPE                 * A,
 
648
   const int                  LDA,
 
649
   const TYPE                 * X,
 
650
   const int                  INCX,
 
651
   const SCALAR               BETA,
 
652
   TYPE                       * Y,
 
653
   const int                  INCY
 
654
)
 
655
{
 
656
   const TYPE                 one [2] = { ATL_rone, ATL_rzero };
 
657
   TYPE                       beta[2];
 
658
 
 
659
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
660
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
661
                        beta, Y, 1 );
 
662
}
 
663
 
 
664
void Mjoin( PATL, gpmvUNc_a1_x1_bXi0_y1 )
 
665
(
 
666
   const int                  M,
 
667
   const int                  N,
 
668
   const SCALAR               ALPHA,
 
669
   const TYPE                 * A,
 
670
   const int                  LDA,
 
671
   const TYPE                 * X,
 
672
   const int                  INCX,
 
673
   const SCALAR               BETA,
 
674
   TYPE                       * Y,
 
675
   const int                  INCY
 
676
)
 
677
{
 
678
   const TYPE                 one [2] = { ATL_rone, ATL_rzero };
 
679
   TYPE                       beta[2];
 
680
 
 
681
   beta[0] = *BETA; beta[1] = ATL_rzero;
 
682
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConj, M, N, one, A, LDA, X, 1,
 
683
                        beta, Y, 1 );
 
684
}
 
685
 
 
686
#endif
 
687
 
 
688
#ifndef USEKERN
 
689
void Mjoin( PATL, gpmvUN_a1_x1_b1_y1 )
 
690
(
 
691
   const int                  M,
 
692
   const int                  N,
 
693
   const SCALAR               ALPHA,
 
694
   const TYPE                 * A,
 
695
   const int                  LDA,
 
696
   const TYPE                 * X,
 
697
   const int                  INCX,
 
698
   const SCALAR               BETA,
 
699
   TYPE                       * Y,
 
700
   const int                  INCY
 
701
)
 
702
{
 
703
#ifdef TREAL
 
704
#define    one                ATL_rone
 
705
#else
 
706
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
707
#endif
 
708
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasNoTrans, M, N, one, A, LDA, X, 1,
 
709
                        one, Y, 1 );
 
710
}
 
711
#endif
 
712
 
 
713
void Mjoin( PATL, gpmvUT_a1_x1_b1_y1 )
 
714
(
 
715
   const int                  M,
 
716
   const int                  N,
 
717
   const SCALAR               ALPHA,
 
718
   const TYPE                 * A,
 
719
   const int                  LDA,
 
720
   const TYPE                 * X,
 
721
   const int                  INCX,
 
722
   const SCALAR               BETA,
 
723
   TYPE                       * Y,
 
724
   const int                  INCY
 
725
)
 
726
{
 
727
#ifdef TREAL
 
728
#define    one                ATL_rone
 
729
#else
 
730
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
731
#endif
 
732
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasTrans, M, N, one, A, LDA, X, 1,
 
733
                        one, Y, 1 );
 
734
}
 
735
 
 
736
#ifdef TCPLX
 
737
void Mjoin( PATL, gpmvUC_a1_x1_b1_y1 )
 
738
(
 
739
   const int                  M,
 
740
   const int                  N,
 
741
   const SCALAR               ALPHA,
 
742
   const TYPE                 * A,
 
743
   const int                  LDA,
 
744
   const TYPE                 * X,
 
745
   const int                  INCX,
 
746
   const SCALAR               BETA,
 
747
   TYPE                       * Y,
 
748
   const int                  INCY
 
749
)
 
750
{
 
751
#ifdef TREAL
 
752
#define    one                ATL_rone
 
753
#else
 
754
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
755
#endif
 
756
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
757
                        one, Y, 1 );
 
758
}
 
759
 
 
760
void Mjoin( PATL, gpmvUNc_a1_x1_b1_y1 )
 
761
(
 
762
   const int                  M,
 
763
   const int                  N,
 
764
   const SCALAR               ALPHA,
 
765
   const TYPE                 * A,
 
766
   const int                  LDA,
 
767
   const TYPE                 * X,
 
768
   const int                  INCX,
 
769
   const SCALAR               BETA,
 
770
   TYPE                       * Y,
 
771
   const int                  INCY
 
772
)
 
773
{
 
774
#ifdef TREAL
 
775
#define    one                ATL_rone
 
776
#else
 
777
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
778
#endif
 
779
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConj, M, N, one, A, LDA, X, 1,
 
780
                        one, Y, 1 );
 
781
}
 
782
 
 
783
#endif
 
784
 
 
785
#ifndef USEKERN
 
786
void Mjoin( PATL, gpmvUN_a1_x1_bX_y1  )
 
787
(
 
788
   const int                  M,
 
789
   const int                  N,
 
790
   const SCALAR               ALPHA,
 
791
   const TYPE                 * A,
 
792
   const int                  LDA,
 
793
   const TYPE                 * X,
 
794
   const int                  INCX,
 
795
   const SCALAR               BETA,
 
796
   TYPE                       * Y,
 
797
   const int                  INCY
 
798
)
 
799
{
 
800
#ifdef TREAL
 
801
#define    one                ATL_rone
 
802
#else
 
803
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
804
#endif
 
805
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasNoTrans, M, N, one, A, LDA, X, 1,
 
806
                        BETA, Y, 1 );
 
807
}
 
808
#endif
 
809
 
 
810
void Mjoin( PATL, gpmvUT_a1_x1_bX_y1 )
 
811
(
 
812
   const int                  M,
 
813
   const int                  N,
 
814
   const SCALAR               ALPHA,
 
815
   const TYPE                 * A,
 
816
   const int                  LDA,
 
817
   const TYPE                 * X,
 
818
   const int                  INCX,
 
819
   const SCALAR               BETA,
 
820
   TYPE                       * Y,
 
821
   const int                  INCY
 
822
)
 
823
{
 
824
#ifdef TREAL
 
825
#define    one                ATL_rone
 
826
#else
 
827
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
828
#endif
 
829
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasTrans, M, N, one, A, LDA, X, 1,
 
830
                        BETA, Y, 1 );
 
831
}
 
832
 
 
833
#ifdef TCPLX
 
834
 
 
835
void Mjoin( PATL, gpmvUC_a1_x1_bX_y1 )
 
836
(
 
837
   const int                  M,
 
838
   const int                  N,
 
839
   const SCALAR               ALPHA,
 
840
   const TYPE                 * A,
 
841
   const int                  LDA,
 
842
   const TYPE                 * X,
 
843
   const int                  INCX,
 
844
   const SCALAR               BETA,
 
845
   TYPE                       * Y,
 
846
   const int                  INCY
 
847
)
 
848
{
 
849
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
850
 
 
851
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConjTrans, M, N, one, A, LDA, X, 1,
 
852
                        BETA, Y, 1 );
 
853
}
 
854
 
 
855
void Mjoin( PATL, gpmvUNc_a1_x1_bX_y1 )
 
856
(
 
857
   const int                  M,
 
858
   const int                  N,
 
859
   const SCALAR               ALPHA,
 
860
   const TYPE                 * A,
 
861
   const int                  LDA,
 
862
   const TYPE                 * X,
 
863
   const int                  INCX,
 
864
   const SCALAR               BETA,
 
865
   TYPE                       * Y,
 
866
   const int                  INCY
 
867
)
 
868
{
 
869
   const TYPE                 one[2] = { ATL_rone, ATL_rzero };
 
870
 
 
871
   Mjoin( PATL, gpmv )( AtlasUpper, AtlasConj, M, N, one, A, LDA, X, 1,
 
872
                        BETA, Y, 1 );
 
873
}
 
874
 
 
875
#endif