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 {
347  FLA_Error r_val = FLA_SUCCESS;
348  scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
349  scomplex* buff_m1 = FLA_COMPLEX_PTR( FLA_MINUS_ONE );
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  {
355  scomplex pivot_val = czero;
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 );
421  FLA_Apply_pivots_ln_opc_var1( mn_behind,
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 {
223  FLA_Error r_val = FLA_SUCCESS;
224  double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
225  double* buff_m1 = FLA_DOUBLE_PTR( FLA_MINUS_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 
279  is_null_pivot = (pivot_val == dzero);
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 );
297  FLA_Apply_pivots_ln_opd_var1( mn_behind,
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 {
98  FLA_Error r_val = FLA_SUCCESS;
99  float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
100  float* buff_m1 = FLA_FLOAT_PTR( FLA_MINUS_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 
155  is_null_pivot = (pivot_val == fzero);
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 );
173  FLA_Apply_pivots_ln_ops_var1( mn_behind,
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 {
17  FLA_Error r_val = FLA_SUCCESS;
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 );
27  rs_A = FLA_Obj_row_stride( A );
28  cs_A = FLA_Obj_col_stride( A );
29 
30  inc_p = FLA_Obj_vector_inc( p );
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 
40  r_val = FLA_LU_piv_ops_var4( m_A,
41  n_A,
42  buff_A, rs_A, cs_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 
53  r_val = FLA_LU_piv_opd_var4( m_A,
54  n_A,
55  buff_A, rs_A, cs_A,
56  buff_p, inc_p );
57 
58  break;
59  }
60 
61  case FLA_COMPLEX:
62  {
63  scomplex* buff_A = FLA_COMPLEX_PTR( A );
64  int* buff_p = FLA_INT_PTR( p );
65 
66  r_val = FLA_LU_piv_opc_var4( m_A,
67  n_A,
68  buff_A, rs_A, cs_A,
69  buff_p, inc_p );
70 
71  break;
72  }
73 
74  case FLA_DOUBLE_COMPLEX:
75  {
76  dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
77  int* buff_p = FLA_INT_PTR( p );
78 
79  r_val = FLA_LU_piv_opz_var4( m_A,
80  n_A,
81  buff_A, rs_A, cs_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(), and FLA_Obj_width().

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 {
471  FLA_Error r_val = FLA_SUCCESS;
472  dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
473  dcomplex* buff_m1 = FLA_DOUBLE_COMPLEX_PTR( FLA_MINUS_ONE );
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  {
479  dcomplex pivot_val = zzero;
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 );
545  FLA_Apply_pivots_ln_opz_var1( mn_behind,
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().