← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/auxil/kernel/ATL_geadd.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/auxil/kernel/ATL_geadd.c
 
1
/*
 
2
 *             Automatically Tuned Linear Algebra Software v3.2
 
3
 *                    (C) Copyright 1999 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 University of Tennessee, the ATLAS group,
 
14
 *      or the names of its contributers may not be used to endorse
 
15
 *      or promote products derived from this software without specific
 
16
 *      written permission.
 
17
 *
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 
19
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 
20
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
21
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE
 
22
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
23
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 
24
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 
25
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 
26
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
27
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
28
 * POSSIBILITY OF SUCH DAMAGE. 
 
29
 *
 
30
 */
 
31
#include "atlas_misc.h"
 
32
 
 
33
#ifdef ALPHA0
 
34
 
 
35
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
 
36
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
37
    const SCALAR beta, TYPE *C, const int ldc)
 
38
/*
 
39
 * C <- alpha*A + beta*C
 
40
 */
 
41
{
 
42
   Mjoin(PATL,Mjoin(gescal,BNM))(M, N, beta, C, ldc);
 
43
}
 
44
 
 
45
#elif defined(BETA0)
 
46
 
 
47
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
 
48
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
49
    const SCALAR beta, TYPE *C, const int ldc)
 
50
/*
 
51
 * C <- alpha*A + beta*C
 
52
 */
 
53
{
 
54
   Mjoin(PATL,Mjoin(gemove,NM))(M, N, alpha, A, lda, C, ldc);
 
55
}
 
56
 
 
57
#else
 
58
 
 
59
#ifdef TREAL
 
60
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
 
61
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
62
    const SCALAR beta, TYPE *C, const int ldc)
 
63
/*
 
64
 * C <- alpha*A + beta*C
 
65
 */
 
66
{
 
67
   const int n = N >> 1, incA = lda << 1, incC = ldc << 1;
 
68
   const TYPE *a0 = A, *a1 = A + lda;
 
69
   register int i, j;
 
70
   TYPE *c0 = C, *c1 = C + ldc;
 
71
 
 
72
   for (j=n; j; j--, c0 += incC, c1 += incC, a0 += incA, a1 += incA)
 
73
   {
 
74
      for (i=0; i != M; i++)
 
75
      {
 
76
         #ifdef BETA0
 
77
            #if defined(ALPHA1)
 
78
               c0[i] = a0[i];
 
79
               c1[i] = a1[i];
 
80
            #else
 
81
               c0[i] = alpha*a0[i];
 
82
               c1[i] = alpha*a1[i];
 
83
            #endif
 
84
         #elif defined(BETA1)
 
85
            #if defined(ALPHA1)
 
86
               c0[i] += a0[i];
 
87
               c1[i] += a1[i];
 
88
            #else
 
89
               c0[i] += alpha*a0[i];
 
90
               c1[i] += alpha*a1[i];
 
91
            #endif
 
92
         #else
 
93
            #if defined(ALPHA1)
 
94
               c0[i] = beta*c0[i] + a0[i];
 
95
               c1[i] = beta*c1[i] + a1[i];
 
96
            #else
 
97
               c0[i] = beta*c0[i] + alpha*a0[i];
 
98
               c1[i] = beta*c1[i] + alpha*a1[i];
 
99
            #endif
 
100
         #endif
 
101
      }
 
102
   }
 
103
   if (N-(n<<1))
 
104
   {
 
105
      for (i=0; i != M; i++)
 
106
      {
 
107
         #ifdef BETA0
 
108
            #if defined(ALPHA1)
 
109
               c0[i] = a0[i];
 
110
            #else
 
111
               c0[i] = alpha*a0[i];
 
112
            #endif
 
113
         #elif defined(BETA1)
 
114
            #if defined(ALPHA1)
 
115
               c0[i] += a0[i];
 
116
            #else
 
117
               c0[i] += alpha*a0[i];
 
118
            #endif
 
119
         #else
 
120
            #if defined(ALPHA1)
 
121
               c0[i] = beta*c0[i] + a0[i];
 
122
            #else
 
123
               c0[i] = beta*c0[i] + alpha*a0[i];
 
124
            #endif
 
125
         #endif
 
126
      }
 
127
   }
 
128
}
 
129
#elif (defined(ALPHA0) && defined(BETA0))
 
130
void Mjoin(PATL,geadd_a0_b0)
 
131
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
132
    const SCALAR beta, TYPE *C, const int ldc)
 
133
{
 
134
   Mjoin(Mjoin(ATL_,UPR),geadd_a0_b0)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
135
}
 
136
#elif (defined(ALPHA0) && defined(BETA1))
 
137
void Mjoin(PATL,geadd_a0_b1)
 
138
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
139
    const SCALAR beta, TYPE *C, const int ldc)
 
140
{
 
141
   Mjoin(Mjoin(ATL_,UPR),geadd_a0_b1)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
142
}
 
143
#elif (defined(ALPHA0) && defined(BETAXI0))
 
144
void Mjoin(PATL,geadd_a0_bXi0)
 
145
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
146
    const SCALAR beta, TYPE *C, const int ldc)
 
147
{
 
148
   Mjoin(Mjoin(ATL_,UPR),geadd_a0_bX)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
149
}
 
150
#elif (defined(ALPHA1) && defined(BETA0))
 
151
void Mjoin(PATL,geadd_a1_b0)
 
152
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
153
    const SCALAR beta, TYPE *C, const int ldc)
 
154
{
 
155
   Mjoin(Mjoin(ATL_,UPR),geadd_a1_b0)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
156
}
 
157
#elif (defined(ALPHA1) && defined(BETA1))
 
158
void Mjoin(PATL,geadd_a1_b1)
 
159
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
160
    const SCALAR beta, TYPE *C, const int ldc)
 
161
{
 
162
   Mjoin(Mjoin(ATL_,UPR),geadd_a1_b1)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
163
}
 
164
#elif (defined(ALPHA1) && defined(BETAXI0))
 
165
void Mjoin(PATL,geadd_a1_bXi0)
 
166
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
167
    const SCALAR beta, TYPE *C, const int ldc)
 
168
{
 
169
   Mjoin(Mjoin(ATL_,UPR),geadd_a1_bX)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
170
}
 
171
#elif (defined(ALPHAXI0) && defined(BETA0))
 
172
void Mjoin(PATL,geadd_aXi0_b0)
 
173
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
174
    const SCALAR beta, TYPE *C, const int ldc)
 
175
{
 
176
   Mjoin(Mjoin(ATL_,UPR),geadd_aX_b0)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
177
}
 
178
#elif (defined(ALPHAXI0) && defined(BETA1))
 
179
void Mjoin(PATL,geadd_aXi0_b1)
 
180
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
181
    const SCALAR beta, TYPE *C, const int ldc)
 
182
{
 
183
   Mjoin(Mjoin(ATL_,UPR),geadd_aX_b1)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
184
}
 
185
#elif (defined(ALPHAXI0) && defined(BETAXI0))
 
186
void Mjoin(PATL,geadd_aXi0_bXi0)
 
187
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
188
    const SCALAR beta, TYPE *C, const int ldc)
 
189
{
 
190
   Mjoin(Mjoin(ATL_,UPR),geadd_aX_bX)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
 
191
}
 
192
#else
 
193
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
 
194
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
 
195
    const SCALAR beta, TYPE *C, const int ldc)
 
196
/*
 
197
 * C <- alpha*A + beta*C
 
198
 */
 
199
{
 
200
   const int incA = (lda-M)<<1, incC = (ldc-M)<<1;
 
201
   register int j, i;
 
202
   const register TYPE ralpha = *alpha, ialpha = alpha[1];
 
203
   const register TYPE rbeta = *beta, ibeta = beta[1];
 
204
   register TYPE cr, ci, ar, ai, t0;
 
205
 
 
206
   for (j=N; j; j--, A += incA, C += incC)
 
207
   {
 
208
      for (i=M; i; i--, A += 2, C += 2)
 
209
      {
 
210
         t0 = cr = *C;
 
211
         ci = C[1];
 
212
         #ifdef BETAXI0
 
213
            cr *= rbeta;
 
214
            ci *= rbeta;
 
215
         #else
 
216
            cr = cr * rbeta - ci * ibeta;
 
217
            ci = t0 * ibeta + ci * rbeta;
 
218
         #endif
 
219
 
 
220
         t0 = ar = *A;
 
221
         ai = A[1];
 
222
         #ifdef ALPHAXI0
 
223
            ar *= ralpha;
 
224
            ai *= ralpha;
 
225
         #else
 
226
            ar = ar * ralpha - ai * ialpha;
 
227
            ai = t0 * ialpha + ai * ralpha;
 
228
         #endif
 
229
 
 
230
         cr += ar;
 
231
         ci += ai;
 
232
         *C = cr;
 
233
         C[1] = ci;
 
234
      }
 
235
   }
 
236
}
 
237
#endif
 
238
 
 
239
#endif