← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/blas/gemv/ATL_mvnk_Mlt16.c

  • Committer: Package Import Robot
  • Author(s): Sébastien Villemot
  • Date: 2013-06-11 15:58:16 UTC
  • mfrom: (1.1.3 upstream)
  • mto: (2.2.21 experimental)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: package-import@ubuntu.com-20130611155816-b72z8f621tuhbzn0
Tags: upstream-3.10.1
Import upstream version 3.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/blas/gemv/ATL_mvnk_Mlt16.c
 
1
/*
 
2
 *             Automatically Tuned Linear Algebra Software v3.10.1
 
3
 * Copyright (C) 2010 R. Clint Whaley
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *   1. Redistributions of source code must retain the above copyright
 
9
 *      notice, this list of conditions and the following disclaimer.
 
10
 *   2. Redistributions in binary form must reproduce the above copyright
 
11
 *      notice, this list of conditions, and the following disclaimer in the
 
12
 *      documentation and/or other materials provided with the distribution.
 
13
 *   3. The name of the ATLAS group or the names of its contributers may
 
14
 *      not be used to endorse or promote products derived from this
 
15
 *      software without specific written permission.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
18
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 
19
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
20
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS
 
21
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
22
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 
23
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 
24
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 
25
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
26
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
27
 * POSSIBILITY OF SUCH DAMAGE.
 
28
 *
 
29
 */
 
30
#include "atlas_misc.h"
 
31
#include "atlas_lvl2.h"
 
32
#include "atlas_lvl3.h"
 
33
#include "atlas_reflevel2.h"
 
34
 
 
35
 
 
36
#ifdef TREAL
 
37
static void ATL_mvn_Meq1
 
38
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
39
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
40
{
 
41
   register int j;
 
42
   register TYPE x0, y0;
 
43
 
 
44
   y0 = ATL_rzero;
 
45
   for (j=0; j < N; j++)
 
46
   {
 
47
      x0 = *X;
 
48
      y0 += A[0] * x0;
 
49
      A += lda;
 
50
      X += incX;
 
51
   }
 
52
   if (beta == ATL_rzero)
 
53
   {
 
54
      Y[0*incY] = y0*alpha;
 
55
   }
 
56
   else if (beta == ATL_rone)
 
57
   {
 
58
      Y[0*incY] += y0*alpha;
 
59
   }
 
60
   else
 
61
   {
 
62
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
63
   }
 
64
}
 
65
static void ATL_mvn_Meq2
 
66
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
67
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
68
{
 
69
   register int j;
 
70
   register TYPE x0, y0, y1;
 
71
 
 
72
   y0 = ATL_rzero;
 
73
   y1 = ATL_rzero;
 
74
   for (j=0; j < N; j++)
 
75
   {
 
76
      x0 = *X;
 
77
      y0 += A[0] * x0;
 
78
      y1 += A[1] * x0;
 
79
      A += lda;
 
80
      X += incX;
 
81
   }
 
82
   if (beta == ATL_rzero)
 
83
   {
 
84
      Y[0*incY] = y0*alpha;
 
85
      Y[1*incY] = y1*alpha;
 
86
   }
 
87
   else if (beta == ATL_rone)
 
88
   {
 
89
      Y[0*incY] += y0*alpha;
 
90
      Y[1*incY] += y1*alpha;
 
91
   }
 
92
   else
 
93
   {
 
94
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
95
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
96
   }
 
97
}
 
98
static void ATL_mvn_Meq3
 
99
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
100
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
101
{
 
102
   register int j;
 
103
   register TYPE x0, y0, y1, y2;
 
104
 
 
105
   y0 = ATL_rzero;
 
106
   y1 = ATL_rzero;
 
107
   y2 = ATL_rzero;
 
108
   for (j=0; j < N; j++)
 
109
   {
 
110
      x0 = *X;
 
111
      y0 += A[0] * x0;
 
112
      y1 += A[1] * x0;
 
113
      y2 += A[2] * x0;
 
114
      A += lda;
 
115
      X += incX;
 
116
   }
 
117
   if (beta == ATL_rzero)
 
118
   {
 
119
      Y[0*incY] = y0*alpha;
 
120
      Y[1*incY] = y1*alpha;
 
121
      Y[2*incY] = y2*alpha;
 
122
   }
 
123
   else if (beta == ATL_rone)
 
124
   {
 
125
      Y[0*incY] += y0*alpha;
 
126
      Y[1*incY] += y1*alpha;
 
127
      Y[2*incY] += y2*alpha;
 
128
   }
 
129
   else
 
130
   {
 
131
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
132
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
133
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
134
   }
 
135
}
 
136
static void ATL_mvn_Meq4
 
137
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
138
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
139
{
 
140
   register int j;
 
141
   register TYPE x0, y0, y1, y2, y3;
 
142
 
 
143
   y0 = ATL_rzero;
 
144
   y1 = ATL_rzero;
 
145
   y2 = ATL_rzero;
 
146
   y3 = ATL_rzero;
 
147
   for (j=0; j < N; j++)
 
148
   {
 
149
      x0 = *X;
 
150
      y0 += A[0] * x0;
 
151
      y1 += A[1] * x0;
 
152
      y2 += A[2] * x0;
 
153
      y3 += A[3] * x0;
 
154
      A += lda;
 
155
      X += incX;
 
156
   }
 
157
   if (beta == ATL_rzero)
 
158
   {
 
159
      Y[0*incY] = y0*alpha;
 
160
      Y[1*incY] = y1*alpha;
 
161
      Y[2*incY] = y2*alpha;
 
162
      Y[3*incY] = y3*alpha;
 
163
   }
 
164
   else if (beta == ATL_rone)
 
165
   {
 
166
      Y[0*incY] += y0*alpha;
 
167
      Y[1*incY] += y1*alpha;
 
168
      Y[2*incY] += y2*alpha;
 
169
      Y[3*incY] += y3*alpha;
 
170
   }
 
171
   else
 
172
   {
 
173
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
174
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
175
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
176
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
177
   }
 
178
}
 
179
static void ATL_mvn_Meq5
 
180
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
181
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
182
{
 
183
   register int j;
 
184
   register TYPE x0, y0, y1, y2, y3, y4;
 
185
 
 
186
   y0 = ATL_rzero;
 
187
   y1 = ATL_rzero;
 
188
   y2 = ATL_rzero;
 
189
   y3 = ATL_rzero;
 
190
   y4 = ATL_rzero;
 
191
   for (j=0; j < N; j++)
 
192
   {
 
193
      x0 = *X;
 
194
      y0 += A[0] * x0;
 
195
      y1 += A[1] * x0;
 
196
      y2 += A[2] * x0;
 
197
      y3 += A[3] * x0;
 
198
      y4 += A[4] * x0;
 
199
      A += lda;
 
200
      X += incX;
 
201
   }
 
202
   if (beta == ATL_rzero)
 
203
   {
 
204
      Y[0*incY] = y0*alpha;
 
205
      Y[1*incY] = y1*alpha;
 
206
      Y[2*incY] = y2*alpha;
 
207
      Y[3*incY] = y3*alpha;
 
208
      Y[4*incY] = y4*alpha;
 
209
   }
 
210
   else if (beta == ATL_rone)
 
211
   {
 
212
      Y[0*incY] += y0*alpha;
 
213
      Y[1*incY] += y1*alpha;
 
214
      Y[2*incY] += y2*alpha;
 
215
      Y[3*incY] += y3*alpha;
 
216
      Y[4*incY] += y4*alpha;
 
217
   }
 
218
   else
 
219
   {
 
220
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
221
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
222
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
223
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
224
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
225
   }
 
226
}
 
227
static void ATL_mvn_Meq6
 
228
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
229
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
230
{
 
231
   register int j;
 
232
   register TYPE x0, y0, y1, y2, y3, y4, y5;
 
233
 
 
234
   y0 = ATL_rzero;
 
235
   y1 = ATL_rzero;
 
236
   y2 = ATL_rzero;
 
237
   y3 = ATL_rzero;
 
238
   y4 = ATL_rzero;
 
239
   y5 = ATL_rzero;
 
240
   for (j=0; j < N; j++)
 
241
   {
 
242
      x0 = *X;
 
243
      y0 += A[0] * x0;
 
244
      y1 += A[1] * x0;
 
245
      y2 += A[2] * x0;
 
246
      y3 += A[3] * x0;
 
247
      y4 += A[4] * x0;
 
248
      y5 += A[5] * x0;
 
249
      A += lda;
 
250
      X += incX;
 
251
   }
 
252
   if (beta == ATL_rzero)
 
253
   {
 
254
      Y[0*incY] = y0*alpha;
 
255
      Y[1*incY] = y1*alpha;
 
256
      Y[2*incY] = y2*alpha;
 
257
      Y[3*incY] = y3*alpha;
 
258
      Y[4*incY] = y4*alpha;
 
259
      Y[5*incY] = y5*alpha;
 
260
   }
 
261
   else if (beta == ATL_rone)
 
262
   {
 
263
      Y[0*incY] += y0*alpha;
 
264
      Y[1*incY] += y1*alpha;
 
265
      Y[2*incY] += y2*alpha;
 
266
      Y[3*incY] += y3*alpha;
 
267
      Y[4*incY] += y4*alpha;
 
268
      Y[5*incY] += y5*alpha;
 
269
   }
 
270
   else
 
271
   {
 
272
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
273
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
274
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
275
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
276
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
277
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
278
   }
 
279
}
 
280
static void ATL_mvn_Meq7
 
281
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
282
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
283
{
 
284
   register int j;
 
285
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6;
 
286
 
 
287
   y0 = ATL_rzero;
 
288
   y1 = ATL_rzero;
 
289
   y2 = ATL_rzero;
 
290
   y3 = ATL_rzero;
 
291
   y4 = ATL_rzero;
 
292
   y5 = ATL_rzero;
 
293
   y6 = ATL_rzero;
 
294
   for (j=0; j < N; j++)
 
295
   {
 
296
      x0 = *X;
 
297
      y0 += A[0] * x0;
 
298
      y1 += A[1] * x0;
 
299
      y2 += A[2] * x0;
 
300
      y3 += A[3] * x0;
 
301
      y4 += A[4] * x0;
 
302
      y5 += A[5] * x0;
 
303
      y6 += A[6] * x0;
 
304
      A += lda;
 
305
      X += incX;
 
306
   }
 
307
   if (beta == ATL_rzero)
 
308
   {
 
309
      Y[0*incY] = y0*alpha;
 
310
      Y[1*incY] = y1*alpha;
 
311
      Y[2*incY] = y2*alpha;
 
312
      Y[3*incY] = y3*alpha;
 
313
      Y[4*incY] = y4*alpha;
 
314
      Y[5*incY] = y5*alpha;
 
315
      Y[6*incY] = y6*alpha;
 
316
   }
 
317
   else if (beta == ATL_rone)
 
318
   {
 
319
      Y[0*incY] += y0*alpha;
 
320
      Y[1*incY] += y1*alpha;
 
321
      Y[2*incY] += y2*alpha;
 
322
      Y[3*incY] += y3*alpha;
 
323
      Y[4*incY] += y4*alpha;
 
324
      Y[5*incY] += y5*alpha;
 
325
      Y[6*incY] += y6*alpha;
 
326
   }
 
327
   else
 
328
   {
 
329
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
330
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
331
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
332
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
333
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
334
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
335
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
336
   }
 
337
}
 
338
static void ATL_mvn_Meq8
 
339
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
340
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
341
{
 
342
   register int j;
 
343
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7;
 
344
 
 
345
   y0 = ATL_rzero;
 
346
   y1 = ATL_rzero;
 
347
   y2 = ATL_rzero;
 
348
   y3 = ATL_rzero;
 
349
   y4 = ATL_rzero;
 
350
   y5 = ATL_rzero;
 
351
   y6 = ATL_rzero;
 
352
   y7 = ATL_rzero;
 
353
   for (j=0; j < N; j++)
 
354
   {
 
355
      x0 = *X;
 
356
      y0 += A[0] * x0;
 
357
      y1 += A[1] * x0;
 
358
      y2 += A[2] * x0;
 
359
      y3 += A[3] * x0;
 
360
      y4 += A[4] * x0;
 
361
      y5 += A[5] * x0;
 
362
      y6 += A[6] * x0;
 
363
      y7 += A[7] * x0;
 
364
      A += lda;
 
365
      X += incX;
 
366
   }
 
367
   if (beta == ATL_rzero)
 
368
   {
 
369
      Y[0*incY] = y0*alpha;
 
370
      Y[1*incY] = y1*alpha;
 
371
      Y[2*incY] = y2*alpha;
 
372
      Y[3*incY] = y3*alpha;
 
373
      Y[4*incY] = y4*alpha;
 
374
      Y[5*incY] = y5*alpha;
 
375
      Y[6*incY] = y6*alpha;
 
376
      Y[7*incY] = y7*alpha;
 
377
   }
 
378
   else if (beta == ATL_rone)
 
379
   {
 
380
      Y[0*incY] += y0*alpha;
 
381
      Y[1*incY] += y1*alpha;
 
382
      Y[2*incY] += y2*alpha;
 
383
      Y[3*incY] += y3*alpha;
 
384
      Y[4*incY] += y4*alpha;
 
385
      Y[5*incY] += y5*alpha;
 
386
      Y[6*incY] += y6*alpha;
 
387
      Y[7*incY] += y7*alpha;
 
388
   }
 
389
   else
 
390
   {
 
391
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
392
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
393
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
394
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
395
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
396
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
397
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
398
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
399
   }
 
400
}
 
401
static void ATL_mvn_Meq9
 
402
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
403
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
404
{
 
405
   register int j;
 
406
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8;
 
407
 
 
408
   y0 = ATL_rzero;
 
409
   y1 = ATL_rzero;
 
410
   y2 = ATL_rzero;
 
411
   y3 = ATL_rzero;
 
412
   y4 = ATL_rzero;
 
413
   y5 = ATL_rzero;
 
414
   y6 = ATL_rzero;
 
415
   y7 = ATL_rzero;
 
416
   y8 = ATL_rzero;
 
417
   for (j=0; j < N; j++)
 
418
   {
 
419
      x0 = *X;
 
420
      y0 += A[0] * x0;
 
421
      y1 += A[1] * x0;
 
422
      y2 += A[2] * x0;
 
423
      y3 += A[3] * x0;
 
424
      y4 += A[4] * x0;
 
425
      y5 += A[5] * x0;
 
426
      y6 += A[6] * x0;
 
427
      y7 += A[7] * x0;
 
428
      y8 += A[8] * x0;
 
429
      A += lda;
 
430
      X += incX;
 
431
   }
 
432
   if (beta == ATL_rzero)
 
433
   {
 
434
      Y[0*incY] = y0*alpha;
 
435
      Y[1*incY] = y1*alpha;
 
436
      Y[2*incY] = y2*alpha;
 
437
      Y[3*incY] = y3*alpha;
 
438
      Y[4*incY] = y4*alpha;
 
439
      Y[5*incY] = y5*alpha;
 
440
      Y[6*incY] = y6*alpha;
 
441
      Y[7*incY] = y7*alpha;
 
442
      Y[8*incY] = y8*alpha;
 
443
   }
 
444
   else if (beta == ATL_rone)
 
445
   {
 
446
      Y[0*incY] += y0*alpha;
 
447
      Y[1*incY] += y1*alpha;
 
448
      Y[2*incY] += y2*alpha;
 
449
      Y[3*incY] += y3*alpha;
 
450
      Y[4*incY] += y4*alpha;
 
451
      Y[5*incY] += y5*alpha;
 
452
      Y[6*incY] += y6*alpha;
 
453
      Y[7*incY] += y7*alpha;
 
454
      Y[8*incY] += y8*alpha;
 
455
   }
 
456
   else
 
457
   {
 
458
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
459
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
460
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
461
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
462
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
463
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
464
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
465
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
466
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
467
   }
 
468
}
 
469
static void ATL_mvn_Meq10
 
470
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
471
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
472
{
 
473
   register int j;
 
474
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;
 
475
 
 
476
   y0 = ATL_rzero;
 
477
   y1 = ATL_rzero;
 
478
   y2 = ATL_rzero;
 
479
   y3 = ATL_rzero;
 
480
   y4 = ATL_rzero;
 
481
   y5 = ATL_rzero;
 
482
   y6 = ATL_rzero;
 
483
   y7 = ATL_rzero;
 
484
   y8 = ATL_rzero;
 
485
   y9 = ATL_rzero;
 
486
   for (j=0; j < N; j++)
 
487
   {
 
488
      x0 = *X;
 
489
      y0 += A[0] * x0;
 
490
      y1 += A[1] * x0;
 
491
      y2 += A[2] * x0;
 
492
      y3 += A[3] * x0;
 
493
      y4 += A[4] * x0;
 
494
      y5 += A[5] * x0;
 
495
      y6 += A[6] * x0;
 
496
      y7 += A[7] * x0;
 
497
      y8 += A[8] * x0;
 
498
      y9 += A[9] * x0;
 
499
      A += lda;
 
500
      X += incX;
 
501
   }
 
502
   if (beta == ATL_rzero)
 
503
   {
 
504
      Y[0*incY] = y0*alpha;
 
505
      Y[1*incY] = y1*alpha;
 
506
      Y[2*incY] = y2*alpha;
 
507
      Y[3*incY] = y3*alpha;
 
508
      Y[4*incY] = y4*alpha;
 
509
      Y[5*incY] = y5*alpha;
 
510
      Y[6*incY] = y6*alpha;
 
511
      Y[7*incY] = y7*alpha;
 
512
      Y[8*incY] = y8*alpha;
 
513
      Y[9*incY] = y9*alpha;
 
514
   }
 
515
   else if (beta == ATL_rone)
 
516
   {
 
517
      Y[0*incY] += y0*alpha;
 
518
      Y[1*incY] += y1*alpha;
 
519
      Y[2*incY] += y2*alpha;
 
520
      Y[3*incY] += y3*alpha;
 
521
      Y[4*incY] += y4*alpha;
 
522
      Y[5*incY] += y5*alpha;
 
523
      Y[6*incY] += y6*alpha;
 
524
      Y[7*incY] += y7*alpha;
 
525
      Y[8*incY] += y8*alpha;
 
526
      Y[9*incY] += y9*alpha;
 
527
   }
 
528
   else
 
529
   {
 
530
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
531
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
532
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
533
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
534
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
535
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
536
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
537
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
538
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
539
      Y[9*incY] = y9*alpha + beta*Y[9*incY];
 
540
   }
 
541
}
 
542
static void ATL_mvn_Meq11
 
543
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
544
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
545
{
 
546
   register int j;
 
547
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10;
 
548
 
 
549
   y0 = ATL_rzero;
 
550
   y1 = ATL_rzero;
 
551
   y2 = ATL_rzero;
 
552
   y3 = ATL_rzero;
 
553
   y4 = ATL_rzero;
 
554
   y5 = ATL_rzero;
 
555
   y6 = ATL_rzero;
 
556
   y7 = ATL_rzero;
 
557
   y8 = ATL_rzero;
 
558
   y9 = ATL_rzero;
 
559
   y10 = ATL_rzero;
 
560
   for (j=0; j < N; j++)
 
561
   {
 
562
      x0 = *X;
 
563
      y0 += A[0] * x0;
 
564
      y1 += A[1] * x0;
 
565
      y2 += A[2] * x0;
 
566
      y3 += A[3] * x0;
 
567
      y4 += A[4] * x0;
 
568
      y5 += A[5] * x0;
 
569
      y6 += A[6] * x0;
 
570
      y7 += A[7] * x0;
 
571
      y8 += A[8] * x0;
 
572
      y9 += A[9] * x0;
 
573
      y10 += A[10] * x0;
 
574
      A += lda;
 
575
      X += incX;
 
576
   }
 
577
   if (beta == ATL_rzero)
 
578
   {
 
579
      Y[0*incY] = y0*alpha;
 
580
      Y[1*incY] = y1*alpha;
 
581
      Y[2*incY] = y2*alpha;
 
582
      Y[3*incY] = y3*alpha;
 
583
      Y[4*incY] = y4*alpha;
 
584
      Y[5*incY] = y5*alpha;
 
585
      Y[6*incY] = y6*alpha;
 
586
      Y[7*incY] = y7*alpha;
 
587
      Y[8*incY] = y8*alpha;
 
588
      Y[9*incY] = y9*alpha;
 
589
      Y[10*incY] = y10*alpha;
 
590
   }
 
591
   else if (beta == ATL_rone)
 
592
   {
 
593
      Y[0*incY] += y0*alpha;
 
594
      Y[1*incY] += y1*alpha;
 
595
      Y[2*incY] += y2*alpha;
 
596
      Y[3*incY] += y3*alpha;
 
597
      Y[4*incY] += y4*alpha;
 
598
      Y[5*incY] += y5*alpha;
 
599
      Y[6*incY] += y6*alpha;
 
600
      Y[7*incY] += y7*alpha;
 
601
      Y[8*incY] += y8*alpha;
 
602
      Y[9*incY] += y9*alpha;
 
603
      Y[10*incY] += y10*alpha;
 
604
   }
 
605
   else
 
606
   {
 
607
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
608
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
609
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
610
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
611
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
612
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
613
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
614
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
615
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
616
      Y[9*incY] = y9*alpha + beta*Y[9*incY];
 
617
      Y[10*incY] = y10*alpha + beta*Y[10*incY];
 
618
   }
 
619
}
 
620
static void ATL_mvn_Meq12
 
621
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
622
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
623
{
 
624
   register int j;
 
625
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11;
 
626
 
 
627
   y0 = ATL_rzero;
 
628
   y1 = ATL_rzero;
 
629
   y2 = ATL_rzero;
 
630
   y3 = ATL_rzero;
 
631
   y4 = ATL_rzero;
 
632
   y5 = ATL_rzero;
 
633
   y6 = ATL_rzero;
 
634
   y7 = ATL_rzero;
 
635
   y8 = ATL_rzero;
 
636
   y9 = ATL_rzero;
 
637
   y10 = ATL_rzero;
 
638
   y11 = ATL_rzero;
 
639
   for (j=0; j < N; j++)
 
640
   {
 
641
      x0 = *X;
 
642
      y0 += A[0] * x0;
 
643
      y1 += A[1] * x0;
 
644
      y2 += A[2] * x0;
 
645
      y3 += A[3] * x0;
 
646
      y4 += A[4] * x0;
 
647
      y5 += A[5] * x0;
 
648
      y6 += A[6] * x0;
 
649
      y7 += A[7] * x0;
 
650
      y8 += A[8] * x0;
 
651
      y9 += A[9] * x0;
 
652
      y10 += A[10] * x0;
 
653
      y11 += A[11] * x0;
 
654
      A += lda;
 
655
      X += incX;
 
656
   }
 
657
   if (beta == ATL_rzero)
 
658
   {
 
659
      Y[0*incY] = y0*alpha;
 
660
      Y[1*incY] = y1*alpha;
 
661
      Y[2*incY] = y2*alpha;
 
662
      Y[3*incY] = y3*alpha;
 
663
      Y[4*incY] = y4*alpha;
 
664
      Y[5*incY] = y5*alpha;
 
665
      Y[6*incY] = y6*alpha;
 
666
      Y[7*incY] = y7*alpha;
 
667
      Y[8*incY] = y8*alpha;
 
668
      Y[9*incY] = y9*alpha;
 
669
      Y[10*incY] = y10*alpha;
 
670
      Y[11*incY] = y11*alpha;
 
671
   }
 
672
   else if (beta == ATL_rone)
 
673
   {
 
674
      Y[0*incY] += y0*alpha;
 
675
      Y[1*incY] += y1*alpha;
 
676
      Y[2*incY] += y2*alpha;
 
677
      Y[3*incY] += y3*alpha;
 
678
      Y[4*incY] += y4*alpha;
 
679
      Y[5*incY] += y5*alpha;
 
680
      Y[6*incY] += y6*alpha;
 
681
      Y[7*incY] += y7*alpha;
 
682
      Y[8*incY] += y8*alpha;
 
683
      Y[9*incY] += y9*alpha;
 
684
      Y[10*incY] += y10*alpha;
 
685
      Y[11*incY] += y11*alpha;
 
686
   }
 
687
   else
 
688
   {
 
689
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
690
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
691
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
692
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
693
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
694
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
695
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
696
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
697
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
698
      Y[9*incY] = y9*alpha + beta*Y[9*incY];
 
699
      Y[10*incY] = y10*alpha + beta*Y[10*incY];
 
700
      Y[11*incY] = y11*alpha + beta*Y[11*incY];
 
701
   }
 
702
}
 
703
static void ATL_mvn_Meq13
 
704
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
705
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
706
{
 
707
   register int j;
 
708
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12;
 
709
 
 
710
   y0 = ATL_rzero;
 
711
   y1 = ATL_rzero;
 
712
   y2 = ATL_rzero;
 
713
   y3 = ATL_rzero;
 
714
   y4 = ATL_rzero;
 
715
   y5 = ATL_rzero;
 
716
   y6 = ATL_rzero;
 
717
   y7 = ATL_rzero;
 
718
   y8 = ATL_rzero;
 
719
   y9 = ATL_rzero;
 
720
   y10 = ATL_rzero;
 
721
   y11 = ATL_rzero;
 
722
   y12 = ATL_rzero;
 
723
   for (j=0; j < N; j++)
 
724
   {
 
725
      x0 = *X;
 
726
      y0 += A[0] * x0;
 
727
      y1 += A[1] * x0;
 
728
      y2 += A[2] * x0;
 
729
      y3 += A[3] * x0;
 
730
      y4 += A[4] * x0;
 
731
      y5 += A[5] * x0;
 
732
      y6 += A[6] * x0;
 
733
      y7 += A[7] * x0;
 
734
      y8 += A[8] * x0;
 
735
      y9 += A[9] * x0;
 
736
      y10 += A[10] * x0;
 
737
      y11 += A[11] * x0;
 
738
      y12 += A[12] * x0;
 
739
      A += lda;
 
740
      X += incX;
 
741
   }
 
742
   if (beta == ATL_rzero)
 
743
   {
 
744
      Y[0*incY] = y0*alpha;
 
745
      Y[1*incY] = y1*alpha;
 
746
      Y[2*incY] = y2*alpha;
 
747
      Y[3*incY] = y3*alpha;
 
748
      Y[4*incY] = y4*alpha;
 
749
      Y[5*incY] = y5*alpha;
 
750
      Y[6*incY] = y6*alpha;
 
751
      Y[7*incY] = y7*alpha;
 
752
      Y[8*incY] = y8*alpha;
 
753
      Y[9*incY] = y9*alpha;
 
754
      Y[10*incY] = y10*alpha;
 
755
      Y[11*incY] = y11*alpha;
 
756
      Y[12*incY] = y12*alpha;
 
757
   }
 
758
   else if (beta == ATL_rone)
 
759
   {
 
760
      Y[0*incY] += y0*alpha;
 
761
      Y[1*incY] += y1*alpha;
 
762
      Y[2*incY] += y2*alpha;
 
763
      Y[3*incY] += y3*alpha;
 
764
      Y[4*incY] += y4*alpha;
 
765
      Y[5*incY] += y5*alpha;
 
766
      Y[6*incY] += y6*alpha;
 
767
      Y[7*incY] += y7*alpha;
 
768
      Y[8*incY] += y8*alpha;
 
769
      Y[9*incY] += y9*alpha;
 
770
      Y[10*incY] += y10*alpha;
 
771
      Y[11*incY] += y11*alpha;
 
772
      Y[12*incY] += y12*alpha;
 
773
   }
 
774
   else
 
775
   {
 
776
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
777
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
778
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
779
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
780
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
781
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
782
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
783
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
784
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
785
      Y[9*incY] = y9*alpha + beta*Y[9*incY];
 
786
      Y[10*incY] = y10*alpha + beta*Y[10*incY];
 
787
      Y[11*incY] = y11*alpha + beta*Y[11*incY];
 
788
      Y[12*incY] = y12*alpha + beta*Y[12*incY];
 
789
   }
 
790
}
 
791
static void ATL_mvn_Meq14
 
792
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
793
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
794
{
 
795
   register int j;
 
796
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12;
 
797
   register TYPE y13;
 
798
 
 
799
   y0 = ATL_rzero;
 
800
   y1 = ATL_rzero;
 
801
   y2 = ATL_rzero;
 
802
   y3 = ATL_rzero;
 
803
   y4 = ATL_rzero;
 
804
   y5 = ATL_rzero;
 
805
   y6 = ATL_rzero;
 
806
   y7 = ATL_rzero;
 
807
   y8 = ATL_rzero;
 
808
   y9 = ATL_rzero;
 
809
   y10 = ATL_rzero;
 
810
   y11 = ATL_rzero;
 
811
   y12 = ATL_rzero;
 
812
   y13 = ATL_rzero;
 
813
   for (j=0; j < N; j++)
 
814
   {
 
815
      x0 = *X;
 
816
      y0 += A[0] * x0;
 
817
      y1 += A[1] * x0;
 
818
      y2 += A[2] * x0;
 
819
      y3 += A[3] * x0;
 
820
      y4 += A[4] * x0;
 
821
      y5 += A[5] * x0;
 
822
      y6 += A[6] * x0;
 
823
      y7 += A[7] * x0;
 
824
      y8 += A[8] * x0;
 
825
      y9 += A[9] * x0;
 
826
      y10 += A[10] * x0;
 
827
      y11 += A[11] * x0;
 
828
      y12 += A[12] * x0;
 
829
      y13 += A[13] * x0;
 
830
      A += lda;
 
831
      X += incX;
 
832
   }
 
833
   if (beta == ATL_rzero)
 
834
   {
 
835
      Y[0*incY] = y0*alpha;
 
836
      Y[1*incY] = y1*alpha;
 
837
      Y[2*incY] = y2*alpha;
 
838
      Y[3*incY] = y3*alpha;
 
839
      Y[4*incY] = y4*alpha;
 
840
      Y[5*incY] = y5*alpha;
 
841
      Y[6*incY] = y6*alpha;
 
842
      Y[7*incY] = y7*alpha;
 
843
      Y[8*incY] = y8*alpha;
 
844
      Y[9*incY] = y9*alpha;
 
845
      Y[10*incY] = y10*alpha;
 
846
      Y[11*incY] = y11*alpha;
 
847
      Y[12*incY] = y12*alpha;
 
848
      Y[13*incY] = y13*alpha;
 
849
   }
 
850
   else if (beta == ATL_rone)
 
851
   {
 
852
      Y[0*incY] += y0*alpha;
 
853
      Y[1*incY] += y1*alpha;
 
854
      Y[2*incY] += y2*alpha;
 
855
      Y[3*incY] += y3*alpha;
 
856
      Y[4*incY] += y4*alpha;
 
857
      Y[5*incY] += y5*alpha;
 
858
      Y[6*incY] += y6*alpha;
 
859
      Y[7*incY] += y7*alpha;
 
860
      Y[8*incY] += y8*alpha;
 
861
      Y[9*incY] += y9*alpha;
 
862
      Y[10*incY] += y10*alpha;
 
863
      Y[11*incY] += y11*alpha;
 
864
      Y[12*incY] += y12*alpha;
 
865
      Y[13*incY] += y13*alpha;
 
866
   }
 
867
   else
 
868
   {
 
869
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
870
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
871
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
872
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
873
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
874
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
875
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
876
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
877
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
878
      Y[9*incY] = y9*alpha + beta*Y[9*incY];
 
879
      Y[10*incY] = y10*alpha + beta*Y[10*incY];
 
880
      Y[11*incY] = y11*alpha + beta*Y[11*incY];
 
881
      Y[12*incY] = y12*alpha + beta*Y[12*incY];
 
882
      Y[13*incY] = y13*alpha + beta*Y[13*incY];
 
883
   }
 
884
}
 
885
static void ATL_mvn_Meq15
 
886
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
887
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
888
{
 
889
   register int j;
 
890
   register TYPE x0, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12;
 
891
   register TYPE y13, y14;
 
892
 
 
893
   y0 = ATL_rzero;
 
894
   y1 = ATL_rzero;
 
895
   y2 = ATL_rzero;
 
896
   y3 = ATL_rzero;
 
897
   y4 = ATL_rzero;
 
898
   y5 = ATL_rzero;
 
899
   y6 = ATL_rzero;
 
900
   y7 = ATL_rzero;
 
901
   y8 = ATL_rzero;
 
902
   y9 = ATL_rzero;
 
903
   y10 = ATL_rzero;
 
904
   y11 = ATL_rzero;
 
905
   y12 = ATL_rzero;
 
906
   y13 = ATL_rzero;
 
907
   y14 = ATL_rzero;
 
908
   for (j=0; j < N; j++)
 
909
   {
 
910
      x0 = *X;
 
911
      y0 += A[0] * x0;
 
912
      y1 += A[1] * x0;
 
913
      y2 += A[2] * x0;
 
914
      y3 += A[3] * x0;
 
915
      y4 += A[4] * x0;
 
916
      y5 += A[5] * x0;
 
917
      y6 += A[6] * x0;
 
918
      y7 += A[7] * x0;
 
919
      y8 += A[8] * x0;
 
920
      y9 += A[9] * x0;
 
921
      y10 += A[10] * x0;
 
922
      y11 += A[11] * x0;
 
923
      y12 += A[12] * x0;
 
924
      y13 += A[13] * x0;
 
925
      y14 += A[14] * x0;
 
926
      A += lda;
 
927
      X += incX;
 
928
   }
 
929
   if (beta == ATL_rzero)
 
930
   {
 
931
      Y[0*incY] = y0*alpha;
 
932
      Y[1*incY] = y1*alpha;
 
933
      Y[2*incY] = y2*alpha;
 
934
      Y[3*incY] = y3*alpha;
 
935
      Y[4*incY] = y4*alpha;
 
936
      Y[5*incY] = y5*alpha;
 
937
      Y[6*incY] = y6*alpha;
 
938
      Y[7*incY] = y7*alpha;
 
939
      Y[8*incY] = y8*alpha;
 
940
      Y[9*incY] = y9*alpha;
 
941
      Y[10*incY] = y10*alpha;
 
942
      Y[11*incY] = y11*alpha;
 
943
      Y[12*incY] = y12*alpha;
 
944
      Y[13*incY] = y13*alpha;
 
945
      Y[14*incY] = y14*alpha;
 
946
   }
 
947
   else if (beta == ATL_rone)
 
948
   {
 
949
      Y[0*incY] += y0*alpha;
 
950
      Y[1*incY] += y1*alpha;
 
951
      Y[2*incY] += y2*alpha;
 
952
      Y[3*incY] += y3*alpha;
 
953
      Y[4*incY] += y4*alpha;
 
954
      Y[5*incY] += y5*alpha;
 
955
      Y[6*incY] += y6*alpha;
 
956
      Y[7*incY] += y7*alpha;
 
957
      Y[8*incY] += y8*alpha;
 
958
      Y[9*incY] += y9*alpha;
 
959
      Y[10*incY] += y10*alpha;
 
960
      Y[11*incY] += y11*alpha;
 
961
      Y[12*incY] += y12*alpha;
 
962
      Y[13*incY] += y13*alpha;
 
963
      Y[14*incY] += y14*alpha;
 
964
   }
 
965
   else
 
966
   {
 
967
      Y[0*incY] = y0*alpha + beta*Y[0*incY];
 
968
      Y[1*incY] = y1*alpha + beta*Y[1*incY];
 
969
      Y[2*incY] = y2*alpha + beta*Y[2*incY];
 
970
      Y[3*incY] = y3*alpha + beta*Y[3*incY];
 
971
      Y[4*incY] = y4*alpha + beta*Y[4*incY];
 
972
      Y[5*incY] = y5*alpha + beta*Y[5*incY];
 
973
      Y[6*incY] = y6*alpha + beta*Y[6*incY];
 
974
      Y[7*incY] = y7*alpha + beta*Y[7*incY];
 
975
      Y[8*incY] = y8*alpha + beta*Y[8*incY];
 
976
      Y[9*incY] = y9*alpha + beta*Y[9*incY];
 
977
      Y[10*incY] = y10*alpha + beta*Y[10*incY];
 
978
      Y[11*incY] = y11*alpha + beta*Y[11*incY];
 
979
      Y[12*incY] = y12*alpha + beta*Y[12*incY];
 
980
      Y[13*incY] = y13*alpha + beta*Y[13*incY];
 
981
      Y[14*incY] = y14*alpha + beta*Y[14*incY];
 
982
   }
 
983
}
 
984
typedef void (*ATL_MVFUNC)
 
985
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
986
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY);
 
987
#endif
 
988
 
 
989
void Mjoin(PATL,mvnk_Mlt16)
 
990
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
991
    const TYPE *X, ATL_CINT incX, const SCALAR beta, TYPE *Y, ATL_CINT incY)
 
992
/*
 
993
 * y = alpha*A*x + beta*y
 
994
 */
 
995
{
 
996
#ifdef TREAL
 
997
   const static ATL_MVFUNC mvfunc[15] = {ATL_mvn_Meq1,
 
998
                                         ATL_mvn_Meq2,
 
999
                                         ATL_mvn_Meq3,
 
1000
                                         ATL_mvn_Meq4,
 
1001
                                         ATL_mvn_Meq5,
 
1002
                                         ATL_mvn_Meq6,
 
1003
                                         ATL_mvn_Meq7,
 
1004
                                         ATL_mvn_Meq8,
 
1005
                                         ATL_mvn_Meq9,
 
1006
                                         ATL_mvn_Meq10,
 
1007
                                         ATL_mvn_Meq11,
 
1008
                                         ATL_mvn_Meq12,
 
1009
                                         ATL_mvn_Meq13,
 
1010
                                         ATL_mvn_Meq14,
 
1011
                                         ATL_mvn_Meq15
 
1012
                                         };
 
1013
 
 
1014
   if ( M < 1 || N < 1 || (SCALAR_IS_ZERO(alpha) && SCALAR_IS_ONE(beta)) )
 
1015
      return;
 
1016
/*
 
1017
 * Base max unrolling we use on how many regs we think we have
 
1018
 */
 
1019
   #ifdef ATL_GAS_x8664
 
1020
   if (M > 14)
 
1021
   #elif defined(ATL_GAS_x8632)
 
1022
   if (M > 6)
 
1023
   #else
 
1024
   if (M > 15)
 
1025
   #endif
 
1026
   {
 
1027
      Mjoin(PATL,mvnk_smallN)(M, N, alpha, A, lda, X, incX, beta, Y, incY);
 
1028
      return;
 
1029
   }
 
1030
   mvfunc[M-1](M, N, alpha, A, lda, X, incX, beta, Y, incY);
 
1031
#else
 
1032
   #ifndef TUNING
 
1033
   if (M <= 8)
 
1034
      Mjoin(PATL,refgemv)(AtlasNoTrans, M, N, alpha, A, lda, X, incX,
 
1035
                          beta, Y, incY);
 
1036
   else
 
1037
   #endif
 
1038
      Mjoin(PATL,mvnk_smallN)(M, N, alpha, A, lda, X, incX, beta, Y, incY);
 
1039
#endif
 
1040
}