libflame revision_anchor
Functions
bl1_axpymrt.c File Reference

(r)

Functions

void bl1_saxpymrt (uplo1_t uplo, trans1_t trans, int m, int n, float *alpha, float *a, int a_rs, int a_cs, float *b, int b_rs, int b_cs)
 
void bl1_daxpymrt (uplo1_t uplo, trans1_t trans, int m, int n, double *alpha, double *a, int a_rs, int a_cs, double *b, int b_rs, int b_cs)
 
void bl1_caxpymrt (uplo1_t uplo, trans1_t trans, int m, int n, scomplex *alpha, scomplex *a, int a_rs, int a_cs, scomplex *b, int b_rs, int b_cs)
 
void bl1_zaxpymrt (uplo1_t uplo, trans1_t trans, int m, int n, dcomplex *alpha, dcomplex *a, int a_rs, int a_cs, dcomplex *b, int b_rs, int b_cs)
 

Function Documentation

◆ bl1_caxpymrt()

void bl1_caxpymrt ( uplo1_t  uplo,
trans1_t  trans,
int  m,
int  n,
scomplex *  alpha,
scomplex *  a,
int  a_rs,
int  a_cs,
scomplex *  b,
int  b_rs,
int  b_cs 
)
228{
229 scomplex* a_begin;
230 scomplex* b_begin;
231 int lda, inca;
232 int ldb, incb;
233 int n_iter;
234 int n_elem;
235 int n_elem_max;
236 int n_elem_is_descending;
237 int j;
238 conj1_t conj;
239
240 // Return early if possible.
241 if ( bl1_zero_dim2( m, n ) ) return;
242
243 // Initialize variables based on storage format of B and value of uplo.
244 if ( bl1_is_col_storage( b_rs, b_cs ) )
245 {
246 if ( bl1_is_lower( uplo ) )
247 {
248 n_iter = bl1_min( m, n );
249 n_elem_max = m;
250 lda = a_cs;
251 inca = a_rs;
252 ldb = b_cs;
253 incb = b_rs;
254 n_elem_is_descending = TRUE;
255 }
256 else // if ( bl1_is_upper( uplo ) )
257 {
258 n_iter = n;
259 n_elem_max = bl1_min( m, n );
260 lda = a_cs;
261 inca = a_rs;
262 ldb = b_cs;
263 incb = b_rs;
264 n_elem_is_descending = FALSE;
265 }
266 }
267 else // if ( bl1_is_row_storage( b_rs, b_cs ) )
268 {
269 if ( bl1_is_lower( uplo ) )
270 {
271 n_iter = m;
272 n_elem_max = bl1_min( m, n );
273 lda = a_rs;
274 inca = a_cs;
275 ldb = b_rs;
276 incb = b_cs;
277 n_elem_is_descending = FALSE;
278 }
279 else // if ( bl1_is_upper( uplo ) )
280 {
281 n_iter = bl1_min( m, n );
282 n_elem_max = n;
283 lda = a_rs;
284 inca = a_cs;
285 ldb = b_rs;
286 incb = b_cs;
287 n_elem_is_descending = TRUE;
288 }
289 }
290
291 // Swap lda and inca if we're doing a transpose.
292 if ( bl1_does_trans( trans ) )
293 {
294 bl1_swap_ints( lda, inca );
295 }
296
297 // Extract conj component from trans parameter.
298 conj = bl1_proj_trans1_to_conj( trans );
299
300 // Choose the loop based on whether n_elem will be shrinking or growing
301 // with each iteration.
302 if ( n_elem_is_descending )
303 {
304 for ( j = 0; j < n_iter; j++ )
305 {
306 n_elem = n_elem_max - j;
307 a_begin = a + j*lda + j*inca;
308 b_begin = b + j*ldb + j*incb;
309
310 bl1_caxpyv( conj,
311 n_elem,
312 alpha,
313 a_begin, inca,
314 b_begin, incb );
315 }
316 }
317 else // if ( n_elem_is_ascending )
318 {
319 for ( j = 0; j < n_iter; j++ )
320 {
321 n_elem = bl1_min( j + 1, n_elem_max );
322 a_begin = a + j*lda;
323 b_begin = b + j*ldb;
324
325 bl1_caxpyv( conj,
326 n_elem,
327 alpha,
328 a_begin, inca,
329 b_begin, incb );
330 }
331 }
332}
i
int i
Definition bl1_axmyv2.c:145
bl1_caxpyv
void bl1_caxpyv(conj1_t conj, int n, scomplex *alpha, scomplex *x, int incx, scomplex *y, int incy)
Definition bl1_axpyv.c:29
bl1_is_lower
int bl1_is_lower(uplo1_t uplo)
Definition bl1_is.c:49
bl1_is_col_storage
int bl1_is_col_storage(int rs, int cs)
Definition bl1_is.c:90
bl1_proj_trans1_to_conj
conj1_t bl1_proj_trans1_to_conj(trans1_t trans)
Definition bl1_proj.c:13
bl1_zero_dim2
int bl1_zero_dim2(int m, int n)
Definition bl1_is.c:118
bl1_does_trans
int bl1_does_trans(trans1_t trans)
Definition bl1_does.c:13
conj1_t
conj1_t
Definition blis_type_defs.h:80
scomplex
Definition blis_type_defs.h:133

References bl1_caxpyv(), bl1_does_trans(), bl1_is_col_storage(), bl1_is_lower(), bl1_proj_trans1_to_conj(), and bl1_zero_dim2().

Referenced by bl1_cher2k(), bl1_cherk(), and FLA_Axpyrt_external().

◆ bl1_daxpymrt()

void bl1_daxpymrt ( uplo1_t  uplo,
trans1_t  trans,
int  m,
int  n,
double *  alpha,
double *  a,
int  a_rs,
int  a_cs,
double *  b,
int  b_rs,
int  b_cs 
)
121{
122 double* a_begin;
123 double* b_begin;
124 int lda, inca;
125 int ldb, incb;
126 int n_iter;
127 int n_elem;
128 int n_elem_max;
129 int n_elem_is_descending;
130 int j;
131 conj1_t conj;
132
133 // Return early if possible.
134 if ( bl1_zero_dim2( m, n ) ) return;
135
136 // Initialize variables based on storage format of B and value of uplo.
137 if ( bl1_is_col_storage( b_rs, b_cs ) )
138 {
139 if ( bl1_is_lower( uplo ) )
140 {
141 n_iter = bl1_min( m, n );
142 n_elem_max = m;
143 lda = a_cs;
144 inca = a_rs;
145 ldb = b_cs;
146 incb = b_rs;
147 n_elem_is_descending = TRUE;
148 }
149 else // if ( bl1_is_upper( uplo ) )
150 {
151 n_iter = n;
152 n_elem_max = bl1_min( m, n );
153 lda = a_cs;
154 inca = a_rs;
155 ldb = b_cs;
156 incb = b_rs;
157 n_elem_is_descending = FALSE;
158 }
159 }
160 else // if ( bl1_is_row_storage( b_rs, b_cs ) )
161 {
162 if ( bl1_is_lower( uplo ) )
163 {
164 n_iter = m;
165 n_elem_max = bl1_min( m, n );
166 lda = a_rs;
167 inca = a_cs;
168 ldb = b_rs;
169 incb = b_cs;
170 n_elem_is_descending = FALSE;
171 }
172 else // if ( bl1_is_upper( uplo ) )
173 {
174 n_iter = bl1_min( m, n );
175 n_elem_max = n;
176 lda = a_rs;
177 inca = a_cs;
178 ldb = b_rs;
179 incb = b_cs;
180 n_elem_is_descending = TRUE;
181 }
182 }
183
184 // Swap lda and inca if we're doing a transpose.
185 if ( bl1_does_trans( trans ) )
186 {
187 bl1_swap_ints( lda, inca );
188 }
189
190 // Extract conj component from trans parameter.
191 conj = bl1_proj_trans1_to_conj( trans );
192
193 // Choose the loop based on whether n_elem will be shrinking or growing
194 // with each iteration.
195 if ( n_elem_is_descending )
196 {
197 for ( j = 0; j < n_iter; j++ )
198 {
199 n_elem = n_elem_max - j;
200 a_begin = a + j*lda + j*inca;
201 b_begin = b + j*ldb + j*incb;
202
203 bl1_daxpyv( conj,
204 n_elem,
205 alpha,
206 a_begin, inca,
207 b_begin, incb );
208 }
209 }
210 else // if ( n_elem_is_ascending )
211 {
212 for ( j = 0; j < n_iter; j++ )
213 {
214 n_elem = bl1_min( j + 1, n_elem_max );
215 a_begin = a + j*lda;
216 b_begin = b + j*ldb;
217
218 bl1_daxpyv( conj,
219 n_elem,
220 alpha,
221 a_begin, inca,
222 b_begin, incb );
223 }
224 }
225}
bl1_daxpyv
void bl1_daxpyv(conj1_t conj, int n, double *alpha, double *x, int incx, double *y, int incy)
Definition bl1_axpyv.c:21

References bl1_daxpyv(), bl1_does_trans(), bl1_is_col_storage(), bl1_is_lower(), bl1_proj_trans1_to_conj(), and bl1_zero_dim2().

Referenced by FLA_Axpyrt_external().

◆ bl1_saxpymrt()

void bl1_saxpymrt ( uplo1_t  uplo,
trans1_t  trans,
int  m,
int  n,
float *  alpha,
float *  a,
int  a_rs,
int  a_cs,
float *  b,
int  b_rs,
int  b_cs 
)
14{
15 float* a_begin;
16 float* b_begin;
17 int lda, inca;
18 int ldb, incb;
19 int n_iter;
20 int n_elem;
21 int n_elem_max;
22 int n_elem_is_descending;
23 int j;
24 conj1_t conj;
25
26 // Return early if possible.
27 if ( bl1_zero_dim2( m, n ) ) return;
28
29 // Initialize variables based on storage format of B and value of uplo.
30 if ( bl1_is_col_storage( b_rs, b_cs ) )
31 {
32 if ( bl1_is_lower( uplo ) )
33 {
34 n_iter = bl1_min( m, n );
35 n_elem_max = m;
36 lda = a_cs;
37 inca = a_rs;
38 ldb = b_cs;
39 incb = b_rs;
40 n_elem_is_descending = TRUE;
41 }
42 else // if ( bl1_is_upper( uplo ) )
43 {
44 n_iter = n;
45 n_elem_max = bl1_min( m, n );
46 lda = a_cs;
47 inca = a_rs;
48 ldb = b_cs;
49 incb = b_rs;
50 n_elem_is_descending = FALSE;
51 }
52 }
53 else // if ( bl1_is_row_storage( b_rs, b_cs ) )
54 {
55 if ( bl1_is_lower( uplo ) )
56 {
57 n_iter = m;
58 n_elem_max = bl1_min( m, n );
59 lda = a_rs;
60 inca = a_cs;
61 ldb = b_rs;
62 incb = b_cs;
63 n_elem_is_descending = FALSE;
64 }
65 else // if ( bl1_is_upper( uplo ) )
66 {
67 n_iter = bl1_min( m, n );
68 n_elem_max = n;
69 lda = a_rs;
70 inca = a_cs;
71 ldb = b_rs;
72 incb = b_cs;
73 n_elem_is_descending = TRUE;
74 }
75 }
76
77 // Swap lda and inca if we're doing a transpose.
78 if ( bl1_does_trans( trans ) )
79 {
80 bl1_swap_ints( lda, inca );
81 }
82
83 // Extract conj component from trans parameter.
84 conj = bl1_proj_trans1_to_conj( trans );
85
86 // Choose the loop based on whether n_elem will be shrinking or growing
87 // with each iteration.
88 if ( n_elem_is_descending )
89 {
90 for ( j = 0; j < n_iter; j++ )
91 {
92 n_elem = n_elem_max - j;
93 a_begin = a + j*lda + j*inca;
94 b_begin = b + j*ldb + j*incb;
95
96 bl1_saxpyv( conj,
97 n_elem,
98 alpha,
99 a_begin, inca,
100 b_begin, incb );
101 }
102 }
103 else // if ( n_elem_is_ascending )
104 {
105 for ( j = 0; j < n_iter; j++ )
106 {
107 n_elem = bl1_min( j + 1, n_elem_max );
108 a_begin = a + j*lda;
109 b_begin = b + j*ldb;
110
111 bl1_saxpyv( conj,
112 n_elem,
113 alpha,
114 a_begin, inca,
115 b_begin, incb );
116 }
117 }
118}
bl1_saxpyv
void bl1_saxpyv(conj1_t conj, int n, float *alpha, float *x, int incx, float *y, int incy)
Definition bl1_axpyv.c:13

References bl1_does_trans(), bl1_is_col_storage(), bl1_is_lower(), bl1_proj_trans1_to_conj(), bl1_saxpyv(), and bl1_zero_dim2().

Referenced by FLA_Axpyrt_external().

◆ bl1_zaxpymrt()

void bl1_zaxpymrt ( uplo1_t  uplo,
trans1_t  trans,
int  m,
int  n,
dcomplex *  alpha,
dcomplex *  a,
int  a_rs,
int  a_cs,
dcomplex *  b,
int  b_rs,
int  b_cs 
)
335{
336 dcomplex* a_begin;
337 dcomplex* b_begin;
338 int lda, inca;
339 int ldb, incb;
340 int n_iter;
341 int n_elem;
342 int n_elem_max;
343 int n_elem_is_descending;
344 int j;
345 conj1_t conj;
346
347 // Return early if possible.
348 if ( bl1_zero_dim2( m, n ) ) return;
349
350 // Initialize variables based on storage format of B and value of uplo.
351 if ( bl1_is_col_storage( b_rs, b_cs ) )
352 {
353 if ( bl1_is_lower( uplo ) )
354 {
355 n_iter = bl1_min( m, n );
356 n_elem_max = m;
357 lda = a_cs;
358 inca = a_rs;
359 ldb = b_cs;
360 incb = b_rs;
361 n_elem_is_descending = TRUE;
362 }
363 else // if ( bl1_is_upper( uplo ) )
364 {
365 n_iter = n;
366 n_elem_max = bl1_min( m, n );
367 lda = a_cs;
368 inca = a_rs;
369 ldb = b_cs;
370 incb = b_rs;
371 n_elem_is_descending = FALSE;
372 }
373 }
374 else // if ( bl1_is_row_storage( b_rs, b_cs ) )
375 {
376 if ( bl1_is_lower( uplo ) )
377 {
378 n_iter = m;
379 n_elem_max = bl1_min( m, n );
380 lda = a_rs;
381 inca = a_cs;
382 ldb = b_rs;
383 incb = b_cs;
384 n_elem_is_descending = FALSE;
385 }
386 else // if ( bl1_is_upper( uplo ) )
387 {
388 n_iter = bl1_min( m, n );
389 n_elem_max = n;
390 lda = a_rs;
391 inca = a_cs;
392 ldb = b_rs;
393 incb = b_cs;
394 n_elem_is_descending = TRUE;
395 }
396 }
397
398 // Swap lda and inca if we're doing a transpose.
399 if ( bl1_does_trans( trans ) )
400 {
401 bl1_swap_ints( lda, inca );
402 }
403
404 // Extract conj component from trans parameter.
405 conj = bl1_proj_trans1_to_conj( trans );
406
407 // Choose the loop based on whether n_elem will be shrinking or growing
408 // with each iteration.
409 if ( n_elem_is_descending )
410 {
411 for ( j = 0; j < n_iter; j++ )
412 {
413 n_elem = n_elem_max - j;
414 a_begin = a + j*lda + j*inca;
415 b_begin = b + j*ldb + j*incb;
416
417 bl1_zaxpyv( conj,
418 n_elem,
419 alpha,
420 a_begin, inca,
421 b_begin, incb );
422 }
423 }
424 else // if ( n_elem_is_ascending )
425 {
426 for ( j = 0; j < n_iter; j++ )
427 {
428 n_elem = bl1_min( j + 1, n_elem_max );
429 a_begin = a + j*lda;
430 b_begin = b + j*ldb;
431
432 bl1_zaxpyv( conj,
433 n_elem,
434 alpha,
435 a_begin, inca,
436 b_begin, incb );
437 }
438 }
439}
bl1_zaxpyv
void bl1_zaxpyv(conj1_t conj, int n, dcomplex *alpha, dcomplex *x, int incx, dcomplex *y, int incy)
Definition bl1_axpyv.c:60
dcomplex
Definition blis_type_defs.h:138

References bl1_does_trans(), bl1_is_col_storage(), bl1_is_lower(), bl1_proj_trans1_to_conj(), bl1_zaxpyv(), and bl1_zero_dim2().

Referenced by bl1_zher2k(), bl1_zherk(), and FLA_Axpyrt_external().

Generated on Thu Sep 23 2021 17:46:17 for libflame by doxygen 1.9.8