← 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: 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/auxil/kernel/ATL_geadd.c
1
1
/*
2
 
 *             Automatically Tuned Linear Algebra Software v3.8.4
3
 
 *                    (C) Copyright 1999 R. Clint Whaley
 
2
 *             Automatically Tuned Linear Algebra Software v3.10.1
 
3
 * Copyright (C) 2009, 1999 R. Clint Whaley
4
4
 *
5
5
 * Redistribution and use in source and binary forms, with or without
6
6
 * modification, are permitted provided that the following conditions
32
32
#ifdef ALPHA0
33
33
 
34
34
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
35
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
36
 
    const SCALAR beta, TYPE *C, const int ldc)
 
35
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
36
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
37
37
/*
38
38
 * C <- alpha*A + beta*C
39
39
 */
44
44
#elif defined(BETA0)
45
45
 
46
46
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
47
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
48
 
    const SCALAR beta, TYPE *C, const int ldc)
 
47
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
48
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
49
49
/*
50
50
 * C <- alpha*A + beta*C
51
51
 */
57
57
 
58
58
#ifdef TREAL
59
59
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
60
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
61
 
    const SCALAR beta, TYPE *C, const int ldc)
 
60
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
61
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
62
62
/*
63
63
 * C <- alpha*A + beta*C
64
64
 */
65
65
{
66
 
   const int n = N >> 1, incA = lda << 1, incC = ldc << 1;
 
66
   ATL_CINT n = N >> 1, incA = lda << 1, incC = ldc << 1;
67
67
   const TYPE *a0 = A, *a1 = A + lda;
68
 
   register int i, j;
 
68
   register ATL_INT i, j;
69
69
   TYPE *c0 = C, *c1 = C + ldc;
70
70
 
71
71
   for (j=n; j; j--, c0 += incC, c1 += incC, a0 += incA, a1 += incA)
127
127
}
128
128
#elif (defined(ALPHA0) && defined(BETA0))
129
129
void Mjoin(PATL,geadd_a0_b0)
130
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
131
 
    const SCALAR beta, TYPE *C, const int ldc)
 
130
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
131
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
132
132
{
133
133
   Mjoin(Mjoin(ATL_,UPR),geadd_a0_b0)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
134
134
}
135
135
#elif (defined(ALPHA0) && defined(BETA1))
136
136
void Mjoin(PATL,geadd_a0_b1)
137
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
138
 
    const SCALAR beta, TYPE *C, const int ldc)
 
137
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
138
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
139
139
{
140
140
   Mjoin(Mjoin(ATL_,UPR),geadd_a0_b1)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
141
141
}
142
142
#elif (defined(ALPHA0) && defined(BETAXI0))
143
143
void Mjoin(PATL,geadd_a0_bXi0)
144
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
145
 
    const SCALAR beta, TYPE *C, const int ldc)
 
144
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
145
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
146
146
{
147
147
   Mjoin(Mjoin(ATL_,UPR),geadd_a0_bX)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
148
148
}
149
149
#elif (defined(ALPHA1) && defined(BETA0))
150
150
void Mjoin(PATL,geadd_a1_b0)
151
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
152
 
    const SCALAR beta, TYPE *C, const int ldc)
 
151
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
152
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
153
153
{
154
154
   Mjoin(Mjoin(ATL_,UPR),geadd_a1_b0)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
155
155
}
156
156
#elif (defined(ALPHA1) && defined(BETA1))
157
157
void Mjoin(PATL,geadd_a1_b1)
158
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
159
 
    const SCALAR beta, TYPE *C, const int ldc)
 
158
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
159
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
160
160
{
161
161
   Mjoin(Mjoin(ATL_,UPR),geadd_a1_b1)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
162
162
}
163
163
#elif (defined(ALPHA1) && defined(BETAXI0))
164
164
void Mjoin(PATL,geadd_a1_bXi0)
165
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
166
 
    const SCALAR beta, TYPE *C, const int ldc)
 
165
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
166
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
167
167
{
168
168
   Mjoin(Mjoin(ATL_,UPR),geadd_a1_bX)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
169
169
}
170
170
#elif (defined(ALPHAXI0) && defined(BETA0))
171
171
void Mjoin(PATL,geadd_aXi0_b0)
172
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
173
 
    const SCALAR beta, TYPE *C, const int ldc)
 
172
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
173
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
174
174
{
175
175
   Mjoin(Mjoin(ATL_,UPR),geadd_aX_b0)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
176
176
}
177
177
#elif (defined(ALPHAXI0) && defined(BETA1))
178
178
void Mjoin(PATL,geadd_aXi0_b1)
179
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
180
 
    const SCALAR beta, TYPE *C, const int ldc)
 
179
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
180
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
181
181
{
182
182
   Mjoin(Mjoin(ATL_,UPR),geadd_aX_b1)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
183
183
}
184
184
#elif (defined(ALPHAXI0) && defined(BETAXI0))
185
185
void Mjoin(PATL,geadd_aXi0_bXi0)
186
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
187
 
    const SCALAR beta, TYPE *C, const int ldc)
 
186
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
187
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
188
188
{
189
189
   Mjoin(Mjoin(ATL_,UPR),geadd_aX_bX)(M<<1, N, *alpha, A, lda<<1, *beta, C, ldc<<1);
190
190
}
191
191
#else
192
192
void Mjoin(Mjoin(Mjoin(PATL,geadd),NM),BNM)
193
 
   (const int M, const int N, const SCALAR alpha, const TYPE *A, const int lda,
194
 
    const SCALAR beta, TYPE *C, const int ldc)
 
193
   (ATL_CINT M, ATL_CINT N, const SCALAR alpha, const TYPE *A, ATL_CINT lda,
 
194
    const SCALAR beta, TYPE *C, ATL_CINT ldc)
195
195
/*
196
196
 * C <- alpha*A + beta*C
197
197
 */
198
198
{
199
 
   const int incA = (lda-M)<<1, incC = (ldc-M)<<1;
200
 
   register int j, i;
 
199
   ATL_CINT incA = (lda-M)<<1, incC = (ldc-M)<<1;
 
200
   register ATL_INT j, i;
201
201
   const register TYPE ralpha = *alpha, ialpha = alpha[1];
202
202
   const register TYPE rbeta = *beta, ibeta = beta[1];
203
203
   register TYPE cr, ci, ar, ai, t0;