libflame revision_anchor
Functions
FLA_LU_piv_opt_var4.c File Reference

(r)

Functions

FLA_Error FLA_LU_piv_opt_var4 (FLA_Obj A, FLA_Obj p)
 
FLA_Error FLA_LU_piv_ops_var4 (int m_A, int n_A, float *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
 
FLA_Error FLA_LU_piv_opd_var4 (int m_A, int n_A, double *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
 
FLA_Error FLA_LU_piv_opc_var4 (int m_A, int n_A, scomplex *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
 
FLA_Error FLA_LU_piv_opz_var4 (int m_A, int n_A, dcomplex *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
 

Function Documentation

◆ FLA_LU_piv_opc_var4()

FLA_Error FLA_LU_piv_opc_var4 ( int  m_A,
int  n_A,
scomplex buff_A,
int  rs_A,
int  cs_A,
int buff_p,
int  inc_p 
)
346{
350 int min_m_n = min( m_A, n_A );
351 int i, is_null_pivot;
352
353 for ( i = 0; i < min_m_n; ++i )
354 {
356 scomplex* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
357 scomplex* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
358 scomplex* a01 = buff_A + (i )*cs_A + (0 )*rs_A;
359 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
360 scomplex* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
361 scomplex* A02 = buff_A + (i+1)*cs_A + (0 )*rs_A;
362 scomplex* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
363
364 int* pi1 = buff_p + i*inc_p;
365
366 int m_ahead = m_A - i - 1;
367 int n_ahead = n_A - i - 1;
368 int mn_behind = i;
369
370 /*------------------------------------------------------------*/
371
372 // FLA_Dots_external( FLA_MINUS_ONE, a10t, a01, FLA_ONE, alpha11 );
374 mn_behind,
375 buff_m1,
376 a10t, cs_A,
377 a01, rs_A,
378 buff_1,
379 alpha11 );
380
381 // FLA_Gemv_external( FLA_NO_TRANSPOSE, FLA_MINUS_ONE, A20, a01, FLA_ONE, a21 );
384 m_ahead,
385 mn_behind,
386 buff_m1,
387 A20, rs_A, cs_A,
388 a01, rs_A,
389 buff_1,
390 a21, rs_A );
391
392 // FLA_Merge_2x1( alpha11,
393 // a21, &aB1 );
394
395 // FLA_Amax_external( aB1, pi1 );
396 bl1_camax( m_ahead + 1,
397 alpha11, rs_A,
398 pi1 );
399
400 // If a null pivot is encountered, return the index.
401 pivot_val =*(alpha11 + *pi1);
402
403 is_null_pivot = (pivot_val.real == czero.real && pivot_val.imag == czero.imag);
404 if ( is_null_pivot )
405 {
406 r_val = ( r_val == FLA_SUCCESS ? i : r_val );
407 }
408 else
409 {
410 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, aB1 );
412 alpha11, rs_A, cs_A,
413 0,
414 0,
415 pi1, inc_p );
416
417 // FLA_Merge_2x1( a10t,
418 // A20, &AB0 );
419
420 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB0 );
422 a10t, rs_A, cs_A,
423 0,
424 0,
425 pi1, inc_p );
426
427 // FLA_Merge_2x1( a12t,
428 // A22, &AB2 );
429
430 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB2 );
432 a12t, rs_A, cs_A,
433 0,
434 0,
435 pi1, inc_p );
436 }
437
438 // FLA_Gemv_external( FLA_TRANSPOSE, FLA_MINUS_ONE, A02, a10t, FLA_ONE, a12t );
441 mn_behind,
442 n_ahead,
443 buff_m1,
444 A02, rs_A, cs_A,
445 a10t, cs_A,
446 buff_1,
447 a12t, cs_A );
448
449 if ( ! is_null_pivot )
450 {
451 // FLA_Inv_scal_external( alpha11, a21 );
453 m_ahead,
454 alpha11,
455 a21, rs_A );
456 }
457 /*------------------------------------------------------------*/
458
459 }
460
461 return r_val;
462}
FLA_Error FLA_Apply_pivots_ln_opc_var1(int n, scomplex *a, int a_rs, int a_cs, int k1, int k2, int *p, int incp)
Definition FLA_Apply_pivots_ln_opt_var1.c:356
const scomplex czero
Definition FLA_Init.c:38
FLA_Obj FLA_MINUS_ONE
Definition FLA_Init.c:22
FLA_Obj FLA_ONE
Definition FLA_Init.c:18
int FLA_Error
Definition FLA_type_defs.h:47
void bl1_camax(int n, scomplex *x, int incx, int *index)
Definition bl1_amax.c:35
int i
Definition bl1_axmyv2.c:145
void bl1_cdots(conj1_t conj, int n, scomplex *alpha, scomplex *x, int incx, scomplex *y, int incy, scomplex *beta, scomplex *rho)
Definition bl1_dots.c:39
void bl1_cgemv(trans1_t transa, conj1_t conjx, int m, int n, scomplex *alpha, scomplex *a, int a_rs, int a_cs, scomplex *x, int incx, scomplex *beta, scomplex *y, int incy)
Definition bl1_gemv.c:125
void bl1_cinvscalv(conj1_t conj, int n, scomplex *alpha, scomplex *x, int incx)
Definition bl1_invscalv.c:52
@ BLIS1_NO_TRANSPOSE
Definition blis_type_defs.h:54
@ BLIS1_TRANSPOSE
Definition blis_type_defs.h:55
@ BLIS1_NO_CONJUGATE
Definition blis_type_defs.h:81
Definition blis_type_defs.h:133
float imag
Definition blis_type_defs.h:134
float real
Definition blis_type_defs.h:134

References bl1_camax(), bl1_cdots(), bl1_cgemv(), bl1_cinvscalv(), BLIS1_NO_CONJUGATE, BLIS1_NO_TRANSPOSE, BLIS1_TRANSPOSE, czero, FLA_Apply_pivots_ln_opc_var1(), FLA_MINUS_ONE, FLA_ONE, i, scomplex::imag, and scomplex::real.

Referenced by FLA_LU_piv_opt_var4().

◆ FLA_LU_piv_opd_var4()

FLA_Error FLA_LU_piv_opd_var4 ( int  m_A,
int  n_A,
double buff_A,
int  rs_A,
int  cs_A,
int buff_p,
int  inc_p 
)
222{
224 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
226 int min_m_n = min( m_A, n_A );
227 int i, is_null_pivot;
228
229 for ( i = 0; i < min_m_n; ++i )
230 {
231 double pivot_val = dzero;
232 double* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
233 double* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
234 double* a01 = buff_A + (i )*cs_A + (0 )*rs_A;
235 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
236 double* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
237 double* A02 = buff_A + (i+1)*cs_A + (0 )*rs_A;
238 double* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
239
240 int* pi1 = buff_p + i*inc_p;
241
242 int m_ahead = m_A - i - 1;
243 int n_ahead = n_A - i - 1;
244 int mn_behind = i;
245
246 /*------------------------------------------------------------*/
247
248 // FLA_Dots_external( FLA_MINUS_ONE, a10t, a01, FLA_ONE, alpha11 );
250 mn_behind,
251 buff_m1,
252 a10t, cs_A,
253 a01, rs_A,
254 buff_1,
255 alpha11 );
256
257 // FLA_Gemv_external( FLA_NO_TRANSPOSE, FLA_MINUS_ONE, A20, a01, FLA_ONE, a21 );
260 m_ahead,
261 mn_behind,
262 buff_m1,
263 A20, rs_A, cs_A,
264 a01, rs_A,
265 buff_1,
266 a21, rs_A );
267
268 // FLA_Merge_2x1( alpha11,
269 // a21, &aB1 );
270
271 // FLA_Amax_external( aB1, pi1 );
272 bl1_damax( m_ahead + 1,
273 alpha11, rs_A,
274 pi1 );
275
276 // If a null pivot is encountered, return the index.
277 pivot_val =*(alpha11 + *pi1);
278
280 if ( is_null_pivot )
281 {
282 r_val = ( r_val == FLA_SUCCESS ? i : r_val );
283 }
284 else
285 {
286 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, aB1 );
288 alpha11, rs_A, cs_A,
289 0,
290 0,
291 pi1, inc_p );
292
293 // FLA_Merge_2x1( a10t,
294 // A20, &AB0 );
295
296 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB0 );
298 a10t, rs_A, cs_A,
299 0,
300 0,
301 pi1, inc_p );
302
303 // FLA_Merge_2x1( a12t,
304 // A22, &AB2 );
305
306 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB2 );
308 a12t, rs_A, cs_A,
309 0,
310 0,
311 pi1, inc_p );
312 }
313
314 // FLA_Gemv_external( FLA_TRANSPOSE, FLA_MINUS_ONE, A02, a10t, FLA_ONE, a12t );
317 mn_behind,
318 n_ahead,
319 buff_m1,
320 A02, rs_A, cs_A,
321 a10t, cs_A,
322 buff_1,
323 a12t, cs_A );
324
325 if ( ! is_null_pivot )
326 {
327 // FLA_Inv_scal_external( alpha11, a21 );
329 m_ahead,
330 alpha11,
331 a21, rs_A );
332 }
333 /*------------------------------------------------------------*/
334
335 }
336
337 return r_val;
338}
FLA_Error FLA_Apply_pivots_ln_opd_var1(int n, double *a, int a_rs, int a_cs, int k1, int k2, int *p, int incp)
Definition FLA_Apply_pivots_ln_opt_var1.c:274
const double dzero
Definition FLA_Init.c:37
void bl1_damax(int n, double *x, int incx, int *index)
Definition bl1_amax.c:24
void bl1_ddots(conj1_t conj, int n, double *alpha, double *x, int incx, double *y, int incy, double *beta, double *rho)
Definition bl1_dots.c:26
void bl1_dgemv(trans1_t transa, conj1_t conjx, int m, int n, double *alpha, double *a, int a_rs, int a_cs, double *x, int incx, double *beta, double *y, int incy)
Definition bl1_gemv.c:69
void bl1_dinvscalv(conj1_t conj, int n, double *alpha, double *x, int incx)
Definition bl1_invscalv.c:26

References bl1_damax(), bl1_ddots(), bl1_dgemv(), bl1_dinvscalv(), BLIS1_NO_CONJUGATE, BLIS1_NO_TRANSPOSE, BLIS1_TRANSPOSE, dzero, FLA_Apply_pivots_ln_opd_var1(), FLA_MINUS_ONE, FLA_ONE, and i.

Referenced by FLA_LU_piv_opt_var4().

◆ FLA_LU_piv_ops_var4()

FLA_Error FLA_LU_piv_ops_var4 ( int  m_A,
int  n_A,
float buff_A,
int  rs_A,
int  cs_A,
int buff_p,
int  inc_p 
)
97{
99 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
101 int min_m_n = min( m_A, n_A );
102 int i, is_null_pivot;
103
104
105 for ( i = 0; i < min_m_n; ++i )
106 {
107 float pivot_val = fzero;
108 float* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
109 float* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
110 float* a01 = buff_A + (i )*cs_A + (0 )*rs_A;
111 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
112 float* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
113 float* A02 = buff_A + (i+1)*cs_A + (0 )*rs_A;
114 float* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
115
116 int* pi1 = buff_p + i*inc_p;
117
118 int m_ahead = m_A - i - 1;
119 int n_ahead = n_A - i - 1;
120 int mn_behind = i;
121
122 /*------------------------------------------------------------*/
123
124 // FLA_Dots_external( FLA_MINUS_ONE, a10t, a01, FLA_ONE, alpha11 );
126 mn_behind,
127 buff_m1,
128 a10t, cs_A,
129 a01, rs_A,
130 buff_1,
131 alpha11 );
132
133 // FLA_Gemv_external( FLA_NO_TRANSPOSE, FLA_MINUS_ONE, A20, a01, FLA_ONE, a21 );
136 m_ahead,
137 mn_behind,
138 buff_m1,
139 A20, rs_A, cs_A,
140 a01, rs_A,
141 buff_1,
142 a21, rs_A );
143
144 // FLA_Merge_2x1( alpha11,
145 // a21, &aB1 );
146
147 // FLA_Amax_external( aB1, pi1 );
148 bl1_samax( m_ahead + 1,
149 alpha11, rs_A,
150 pi1 );
151
152 // If a null pivot is encountered, return the index.
153 pivot_val = *(alpha11 + *pi1);
154
156 if ( is_null_pivot )
157 {
158 r_val = ( r_val == FLA_SUCCESS ? i : r_val );
159 }
160 else
161 {
162 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, aB1 );
164 alpha11, rs_A, cs_A,
165 0,
166 0,
167 pi1, inc_p );
168
169 // FLA_Merge_2x1( a10t,
170 // A20, &AB0 );
171
172 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB0 );
174 a10t, rs_A, cs_A,
175 0,
176 0,
177 pi1, inc_p );
178
179 // FLA_Merge_2x1( a12t,
180 // A22, &AB2 );
181
182 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB2 );
184 a12t, rs_A, cs_A,
185 0,
186 0,
187 pi1, inc_p );
188 }
189
190 // FLA_Gemv_external( FLA_TRANSPOSE, FLA_MINUS_ONE, A02, a10t, FLA_ONE, a12t );
193 mn_behind,
194 n_ahead,
195 buff_m1,
196 A02, rs_A, cs_A,
197 a10t, cs_A,
198 buff_1,
199 a12t, cs_A );
200
201 if ( ! is_null_pivot )
202 {
203 // FLA_Inv_scal_external( alpha11, a21 );
205 m_ahead,
206 alpha11,
207 a21, rs_A );
208 }
209 /*------------------------------------------------------------*/
210
211 }
212
213 return r_val;
214}
FLA_Error FLA_Apply_pivots_ln_ops_var1(int n, float *a, int a_rs, int a_cs, int k1, int k2, int *p, int incp)
Definition FLA_Apply_pivots_ln_opt_var1.c:192
const float fzero
Definition FLA_Init.c:36
void bl1_samax(int n, float *x, int incx, int *index)
Definition bl1_amax.c:13
void bl1_sdots(conj1_t conj, int n, float *alpha, float *x, int incx, float *y, int incy, float *beta, float *rho)
Definition bl1_dots.c:13
void bl1_sgemv(trans1_t transa, conj1_t conjx, int m, int n, float *alpha, float *a, int a_rs, int a_cs, float *x, int incx, float *beta, float *y, int incy)
Definition bl1_gemv.c:13
void bl1_sinvscalv(conj1_t conj, int n, float *alpha, float *x, int incx)
Definition bl1_invscalv.c:13

References bl1_samax(), bl1_sdots(), bl1_sgemv(), bl1_sinvscalv(), BLIS1_NO_CONJUGATE, BLIS1_NO_TRANSPOSE, BLIS1_TRANSPOSE, FLA_Apply_pivots_ln_ops_var1(), FLA_MINUS_ONE, FLA_ONE, fzero, and i.

Referenced by FLA_LU_piv_opt_var4().

◆ FLA_LU_piv_opt_var4()

FLA_Error FLA_LU_piv_opt_var4 ( FLA_Obj  A,
FLA_Obj  p 
)
16{
18 FLA_Datatype datatype;
19 int m_A, n_A;
20 int rs_A, cs_A;
21 int inc_p;
22
23 datatype = FLA_Obj_datatype( A );
24
25 m_A = FLA_Obj_length( A );
26 n_A = FLA_Obj_width( A );
29
31
32
33 switch ( datatype )
34 {
35 case FLA_FLOAT:
36 {
37 float* buff_A = FLA_FLOAT_PTR( A );
38 int* buff_p = FLA_INT_PTR( p );
39
41 n_A,
43 buff_p, inc_p );
44
45 break;
46 }
47
48 case FLA_DOUBLE:
49 {
50 double* buff_A = FLA_DOUBLE_PTR( A );
51 int* buff_p = FLA_INT_PTR( p );
52
54 n_A,
56 buff_p, inc_p );
57
58 break;
59 }
60
61 case FLA_COMPLEX:
62 {
64 int* buff_p = FLA_INT_PTR( p );
65
67 n_A,
69 buff_p, inc_p );
70
71 break;
72 }
73
75 {
77 int* buff_p = FLA_INT_PTR( p );
78
80 n_A,
82 buff_p, inc_p );
83
84 break;
85 }
86 }
87
88 return r_val;
89}
FLA_Error FLA_LU_piv_opc_var4(int m_A, int n_A, scomplex *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
Definition FLA_LU_piv_opt_var4.c:342
FLA_Error FLA_LU_piv_ops_var4(int m_A, int n_A, float *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
Definition FLA_LU_piv_opt_var4.c:93
FLA_Error FLA_LU_piv_opd_var4(int m_A, int n_A, double *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
Definition FLA_LU_piv_opt_var4.c:218
FLA_Error FLA_LU_piv_opz_var4(int m_A, int n_A, dcomplex *buff_A, int rs_A, int cs_A, int *buff_p, int inc_p)
Definition FLA_LU_piv_opt_var4.c:466
dim_t FLA_Obj_width(FLA_Obj obj)
Definition FLA_Query.c:123
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition FLA_Query.c:167
dim_t FLA_Obj_length(FLA_Obj obj)
Definition FLA_Query.c:116
dim_t FLA_Obj_col_stride(FLA_Obj obj)
Definition FLA_Query.c:174
dim_t FLA_Obj_vector_inc(FLA_Obj obj)
Definition FLA_Query.c:145
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition FLA_Query.c:13
int FLA_Datatype
Definition FLA_type_defs.h:49
Definition blis_type_defs.h:138

References FLA_LU_piv_opc_var4(), FLA_LU_piv_opd_var4(), FLA_LU_piv_ops_var4(), FLA_LU_piv_opz_var4(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_Obj_width(), and i.

Referenced by FLA_LU_piv_internal().

◆ FLA_LU_piv_opz_var4()

FLA_Error FLA_LU_piv_opz_var4 ( int  m_A,
int  n_A,
dcomplex buff_A,
int  rs_A,
int  cs_A,
int buff_p,
int  inc_p 
)
470{
474 int min_m_n = min( m_A, n_A );
475 int i, is_null_pivot;
476
477 for ( i = 0; i < min_m_n; ++i )
478 {
480 dcomplex* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
481 dcomplex* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
482 dcomplex* a01 = buff_A + (i )*cs_A + (0 )*rs_A;
483 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
484 dcomplex* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
485 dcomplex* A02 = buff_A + (i+1)*cs_A + (0 )*rs_A;
486 dcomplex* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
487
488 int* pi1 = buff_p + i*inc_p;
489
490 int m_ahead = m_A - i - 1;
491 int n_ahead = n_A - i - 1;
492 int mn_behind = i;
493
494 /*------------------------------------------------------------*/
495
496 // FLA_Dots_external( FLA_MINUS_ONE, a10t, a01, FLA_ONE, alpha11 );
498 mn_behind,
499 buff_m1,
500 a10t, cs_A,
501 a01, rs_A,
502 buff_1,
503 alpha11 );
504
505 // FLA_Gemv_external( FLA_NO_TRANSPOSE, FLA_MINUS_ONE, A20, a01, FLA_ONE, a21 );
508 m_ahead,
509 mn_behind,
510 buff_m1,
511 A20, rs_A, cs_A,
512 a01, rs_A,
513 buff_1,
514 a21, rs_A );
515
516 // FLA_Merge_2x1( alpha11,
517 // a21, &aB1 );
518
519 // FLA_Amax_external( aB1, pi1 );
520 bl1_zamax( m_ahead + 1,
521 alpha11, rs_A,
522 pi1 );
523
524 // If a null pivot is encountered, return the index.
525 pivot_val =*(alpha11 + *pi1);
526
527 is_null_pivot = (pivot_val.real == zzero.real && pivot_val.imag == zzero.imag);
528 if ( is_null_pivot )
529 {
530 r_val = ( r_val == FLA_SUCCESS ? i : r_val );
531 }
532 else
533 {
534 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, aB1 );
536 alpha11, rs_A, cs_A,
537 0,
538 0,
539 pi1, inc_p );
540
541 // FLA_Merge_2x1( a10t,
542 // A20, &AB0 );
543
544 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB0 );
546 a10t, rs_A, cs_A,
547 0,
548 0,
549 pi1, inc_p );
550
551 // FLA_Merge_2x1( a12t,
552 // A22, &AB2 );
553
554 // FLA_Apply_pivots( FLA_LEFT, FLA_NO_TRANSPOSE, pi1, AB2 );
556 a12t, rs_A, cs_A,
557 0,
558 0,
559 pi1, inc_p );
560 }
561
562 // FLA_Gemv_external( FLA_TRANSPOSE, FLA_MINUS_ONE, A02, a10t, FLA_ONE, a12t );
565 mn_behind,
566 n_ahead,
567 buff_m1,
568 A02, rs_A, cs_A,
569 a10t, cs_A,
570 buff_1,
571 a12t, cs_A );
572
573 if ( ! is_null_pivot )
574 {
575 // FLA_Inv_scal_external( alpha11, a21 );
577 m_ahead,
578 alpha11,
579 a21, rs_A );
580 }
581 /*------------------------------------------------------------*/
582
583 }
584
585 return r_val;
586}
FLA_Error FLA_Apply_pivots_ln_opz_var1(int n, dcomplex *a, int a_rs, int a_cs, int k1, int k2, int *p, int incp)
Definition FLA_Apply_pivots_ln_opt_var1.c:438
const dcomplex zzero
Definition FLA_Init.c:39
void bl1_zamax(int n, dcomplex *x, int incx, int *index)
Definition bl1_amax.c:46
void bl1_zdots(conj1_t conj, int n, dcomplex *alpha, dcomplex *x, int incx, dcomplex *y, int incy, dcomplex *beta, dcomplex *rho)
Definition bl1_dots.c:56
void bl1_zgemv(trans1_t transa, conj1_t conjx, int m, int n, dcomplex *alpha, dcomplex *a, int a_rs, int a_cs, dcomplex *x, int incx, dcomplex *beta, dcomplex *y, int incy)
Definition bl1_gemv.c:255
void bl1_zinvscalv(conj1_t conj, int n, dcomplex *alpha, dcomplex *x, int incx)
Definition bl1_invscalv.c:78
double real
Definition blis_type_defs.h:139
double imag
Definition blis_type_defs.h:139

References bl1_zamax(), bl1_zdots(), bl1_zgemv(), bl1_zinvscalv(), BLIS1_NO_CONJUGATE, BLIS1_NO_TRANSPOSE, BLIS1_TRANSPOSE, FLA_Apply_pivots_ln_opz_var1(), FLA_MINUS_ONE, FLA_ONE, i, dcomplex::imag, dcomplex::real, and zzero.

Referenced by FLA_LU_piv_opt_var4().