libflame  revision_anchor
Functions
FLA_Tridiag_UT.h File Reference

(r)

Go to the source code of this file.

Functions

FLA_Error FLA_Tridiag_UT (FLA_Uplo uplo, FLA_Obj A, FLA_Obj T)
 
FLA_Error FLA_Tridiag_UT_internal (FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, fla_tridiagut_t *cntl)
 
FLA_Error FLA_Tridiag_UT_l (FLA_Obj A, FLA_Obj T, fla_tridiagut_t *cntl)
 
FLA_Error FLA_Tridiag_UT_u (FLA_Obj A, FLA_Obj T, fla_tridiagut_t *cntl)
 
FLA_Error FLA_Tridiag_UT_create_T (FLA_Obj A, FLA_Obj *T)
 
FLA_Error FLA_Tridiag_UT_recover_tau (FLA_Obj T, FLA_Obj t)
 
FLA_Error FLA_Tridiag_UT_scale_diagonals (FLA_Uplo uplo, FLA_Obj alpha, FLA_Obj A)
 
FLA_Error FLA_Tridiag_UT_extract_diagonals (FLA_Uplo uplo, FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Tridiag_UT_extract_real_diagonals (FLA_Uplo uplo, FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Tridiag_UT_realify (FLA_Uplo uplo, FLA_Obj A, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_l_realify_unb (FLA_Obj A, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_l_realify_opt (FLA_Obj A, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_u_realify_unb (FLA_Obj A, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_u_realify_opt (FLA_Obj A, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_realify_subdiagonal (FLA_Obj b, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_realify_subdiagonal_opt (FLA_Obj b, FLA_Obj d)
 
FLA_Error FLA_Tridiag_UT_shift_U (FLA_Uplo uplo, FLA_Obj A)
 
FLA_Error FLA_Tridiag_UT_shift_U_l_ops (int m_A, float *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_u_ops (int m_A, float *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_l_opd (int m_A, double *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_u_opd (int m_A, double *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_l_opc (int m_A, scomplex *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_u_opc (int m_A, scomplex *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_l_opz (int m_A, dcomplex *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_shift_U_u_opz (int m_A, dcomplex *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Tridiag_UT_form_Q (FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, FLA_Obj Q)
 
FLA_Error FLA_Tridiag_UT_form_Q_l_blk_var1 (FLA_Obj A, FLA_Obj T, FLA_Obj W)
 
FLA_Error FLA_Tridiag_UT_form_Q_u_blk_var1 (FLA_Obj A, FLA_Obj T, FLA_Obj W)
 
FLA_Error FLA_Tridiag_UT_form_Q_l_opt_var1 (FLA_Obj A, FLA_Obj T)
 
FLA_Error FLA_Tridiag_UT_form_Q_l_ops_var1 (int m_A, int n_AT, float *buff_A, int rs_A, int cs_A, float *buff_T, int rs_T, int cs_T)
 
FLA_Error FLA_Tridiag_UT_form_Q_l_opd_var1 (int m_A, int n_AT, double *buff_A, int rs_A, int cs_A, double *buff_T, int rs_T, int cs_T)
 
FLA_Error FLA_Tridiag_UT_form_Q_l_opc_var1 (int m_A, int n_AT, scomplex *buff_A, int rs_A, int cs_A, scomplex *buff_T, int rs_T, int cs_T)
 
FLA_Error FLA_Tridiag_UT_form_Q_l_opz_var1 (int m_A, int n_AT, dcomplex *buff_A, int rs_A, int cs_A, dcomplex *buff_T, int rs_T, int cs_T)
 

Function Documentation

◆ FLA_Tridiag_UT()

FLA_Error FLA_Tridiag_UT ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  T 
)
18 {
19  FLA_Error r_val;
20 
21  // Check parameters.
22  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
23  FLA_Tridiag_UT_check( uplo, A, T );
24 
25  if ( FLA_Obj_row_stride( A ) == 1 &&
27  // Temporary fix not to use the fused version (numerically unstable).
29  else
31 
32  return r_val;
33 }
fla_tridiagut_t * fla_tridiagut_cntl_plain
Definition: FLA_Tridiag_UT_cntl_init.c:15
fla_tridiagut_t * fla_tridiagut_cntl_nofus
Definition: FLA_Tridiag_UT_cntl_init.c:14
FLA_Error FLA_Tridiag_UT_internal(FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, fla_tridiagut_t *cntl)
Definition: FLA_Tridiag_UT_internal.c:13
FLA_Error FLA_Tridiag_UT_check(FLA_Uplo uplo, FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_check.c:13
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition: FLA_Query.c:167
unsigned int FLA_Check_error_level(void)
Definition: FLA_Check.c:18
FLA_Bool FLA_Obj_is_double_precision(FLA_Obj A)
Definition: FLA_Query.c:358
int FLA_Error
Definition: FLA_type_defs.h:47

References FLA_Check_error_level(), FLA_Obj_is_double_precision(), FLA_Obj_row_stride(), FLA_Tridiag_UT_check(), FLA_Tridiag_UT_internal(), fla_tridiagut_cntl_nofus, and fla_tridiagut_cntl_plain.

Referenced by FLA_Hevd_lv_unb_var1(), and FLA_Hevd_lv_unb_var2().

◆ FLA_Tridiag_UT_create_T()

FLA_Error FLA_Tridiag_UT_create_T ( FLA_Obj  A,
FLA_Obj T 
)
14 {
15  FLA_Datatype datatype;
16  dim_t b_alg, k;
17  dim_t rs_T, cs_T;
18 
19  // Query the datatype of A.
20  datatype = FLA_Obj_datatype( A );
21 
22  // Query the blocksize from the library.
23  b_alg = FLA_Query_blocksize( datatype, FLA_DIMENSION_MIN );
24 
25  // Scale the blocksize by a pre-set global constant.
26  b_alg = ( dim_t )( ( ( double ) b_alg ) * FLA_TRIDIAG_INNER_TO_OUTER_B_RATIO );
27 
28  // Query the minimum dimension of A.
29  k = FLA_Obj_min_dim( A );
30 
31  // Adjust the blocksize with respect to the min-dim of A.
32  b_alg = min( b_alg, k );
33 
34  // Figure out whether T should be row-major or column-major.
35  if ( FLA_Obj_row_stride( A ) == 1 )
36  {
37  rs_T = 1;
38  cs_T = b_alg;
39  }
40  else // if ( FLA_Obj_col_stride( A ) == 1 )
41  {
42  rs_T = k;
43  cs_T = 1;
44  }
45 
46  // Create a b_alg x k matrix to hold the block Householder transforms that
47  // will be accumulated within the tridiagonal reduction algorithm.
48  FLA_Obj_create( datatype, b_alg, k, rs_T, cs_T, T );
49 
50  return FLA_SUCCESS;
51 }
FLA_Error FLA_Obj_create(FLA_Datatype datatype, dim_t m, dim_t n, dim_t rs, dim_t cs, FLA_Obj *obj)
Definition: FLA_Obj.c:55
dim_t FLA_Query_blocksize(FLA_Datatype dt, FLA_Dimension dim)
Definition: FLA_Blocksize.c:161
dim_t FLA_Obj_min_dim(FLA_Obj obj)
Definition: FLA_Query.c:153
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
int FLA_Datatype
Definition: FLA_type_defs.h:49
unsigned long dim_t
Definition: FLA_type_defs.h:71

References FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_min_dim(), FLA_Obj_row_stride(), and FLA_Query_blocksize().

Referenced by FLA_Hevd_lv_unb_var1(), and FLA_Hevd_lv_unb_var2().

◆ FLA_Tridiag_UT_extract_diagonals()

FLA_Error FLA_Tridiag_UT_extract_diagonals ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
19 
20  if ( uplo == FLA_LOWER_TRIANGULAR )
21  r_val = FLA_Bidiag_UT_l_extract_diagonals( A, d, e );
22  else
23  r_val = FLA_Bidiag_UT_u_extract_diagonals( A, d, e );
24 
25  return r_val;
26 }
FLA_Error FLA_Bidiag_UT_l_extract_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Bidiag_UT_extract_diagonals.c:165
FLA_Error FLA_Bidiag_UT_u_extract_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Bidiag_UT_extract_diagonals.c:30
FLA_Error FLA_Tridiag_UT_extract_diagonals_check(FLA_Uplo uplo, FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Tridiag_UT_extract_diagonals_check.c:13

References FLA_Bidiag_UT_l_extract_diagonals(), FLA_Bidiag_UT_u_extract_diagonals(), FLA_Check_error_level(), and FLA_Tridiag_UT_extract_diagonals_check().

◆ FLA_Tridiag_UT_extract_real_diagonals()

FLA_Error FLA_Tridiag_UT_extract_real_diagonals ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
19 
20  if ( uplo == FLA_LOWER_TRIANGULAR )
21  r_val = FLA_Bidiag_UT_l_extract_real_diagonals( A, d, e );
22  else
23  r_val = FLA_Bidiag_UT_u_extract_real_diagonals( A, d, e );
24 
25  return r_val;
26 }
FLA_Error FLA_Bidiag_UT_l_extract_real_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Bidiag_UT_extract_real_diagonals.c:163
FLA_Error FLA_Bidiag_UT_u_extract_real_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Bidiag_UT_extract_real_diagonals.c:28
FLA_Error FLA_Tridiag_UT_extract_real_diagonals_check(FLA_Uplo uplo, FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Tridiag_UT_extract_real_diagonals_check.c:13

References FLA_Bidiag_UT_l_extract_real_diagonals(), FLA_Bidiag_UT_u_extract_real_diagonals(), FLA_Check_error_level(), and FLA_Tridiag_UT_extract_real_diagonals_check().

Referenced by FLA_Hevd_lv_unb_var1(), and FLA_Hevd_lv_unb_var2().

◆ FLA_Tridiag_UT_form_Q()

FLA_Error FLA_Tridiag_UT_form_Q ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  T,
FLA_Obj  Q 
)
15 {
16  FLA_Error r_val = FLA_SUCCESS;
17  FLA_Obj ATL, ATR,
18  ABL, ABR;
19  FLA_Obj QTL, QTR,
20  QBL, QBR;
21  FLA_Obj TL, TR;
22 
23  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
24  FLA_Tridiag_UT_form_Q_check( uplo, A, T, Q );
25 
26  // Adjust T.
27  FLA_Part_1x2( T, &TL, &TR, 1, FLA_RIGHT );
28 
29  if ( FLA_Obj_is( A, Q ) == FALSE )
30  {
31  FLA_Part_2x2( Q, &QTL, &QTR,
32  &QBL, &QBR, 1, 1, FLA_TL );
33 
34  FLA_Set( FLA_ONE, QTL );
35  FLA_Set( FLA_ZERO, QTR );
36  FLA_Set( FLA_ZERO, QBL );
37 
38  if ( uplo == FLA_LOWER_TRIANGULAR )
39  {
40  FLA_Part_2x2( A, &ATL, &ATR,
41  &ABL, &ABR, 1, 1, FLA_TR );
42  FLA_QR_UT_form_Q( ABL, TL, QBR );
43  }
44  else // ( uplo == FLA_UPPER_TRIANGULAR )
45  {
46  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
47  }
48  }
49  else
50  {
51  // Shift the Householder vectors one row/column towards the diagonal.
52  FLA_Tridiag_UT_shift_U( uplo, A );
53 
54  FLA_Part_2x2( A, &ATL, &ATR,
55  &ABL, &ABR, 1, 1, FLA_TL );
56 
57  if ( uplo == FLA_LOWER_TRIANGULAR )
58  {
59  FLA_QR_UT_form_Q( ABR, TL, ABR );
60  }
61  else // ( uplo == FLA_UPPER_TRIANGULAR )
62  {
63  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
64  }
65  }
66  return r_val;
67 }
FLA_Error FLA_QR_UT_form_Q(FLA_Obj A, FLA_Obj T, FLA_Obj Q)
Definition: FLA_QR_UT_form_Q.c:13
FLA_Error FLA_Tridiag_UT_shift_U(FLA_Uplo uplo, FLA_Obj A)
Definition: FLA_Tridiag_UT_shift_U.c:13
FLA_Error FLA_Tridiag_UT_form_Q_check(FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, FLA_Obj Q)
Definition: FLA_Tridiag_UT_form_Q_check.c:13
FLA_Obj FLA_ZERO
Definition: FLA_Init.c:20
FLA_Obj FLA_ONE
Definition: FLA_Init.c:18
FLA_Error FLA_Part_2x2(FLA_Obj A, FLA_Obj *A11, FLA_Obj *A12, FLA_Obj *A21, FLA_Obj *A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)
Definition: FLA_View.c:17
FLA_Error FLA_Part_1x2(FLA_Obj A, FLA_Obj *A1, FLA_Obj *A2, dim_t nb, FLA_Side side)
Definition: FLA_View.c:110
FLA_Bool FLA_Obj_is(FLA_Obj A, FLA_Obj B)
Definition: FLA_Query.c:460
FLA_Error FLA_Set(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Set.c:13
Definition: FLA_type_defs.h:159

References FLA_Check_error_level(), FLA_Obj_is(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x2(), FLA_QR_UT_form_Q(), FLA_Set(), FLA_Tridiag_UT_form_Q_check(), FLA_Tridiag_UT_shift_U(), and FLA_ZERO.

Referenced by FLA_Hevd_lv_unb_var1(), and FLA_Hevd_lv_unb_var2().

◆ FLA_Tridiag_UT_form_Q_l_blk_var1()

FLA_Error FLA_Tridiag_UT_form_Q_l_blk_var1 ( FLA_Obj  A,
FLA_Obj  T,
FLA_Obj  W 
)

◆ FLA_Tridiag_UT_form_Q_l_opc_var1()

FLA_Error FLA_Tridiag_UT_form_Q_l_opc_var1 ( int  m_A,
int  n_AT,
scomplex buff_A,
int  rs_A,
int  cs_A,
scomplex buff_T,
int  rs_T,
int  cs_T 
)

◆ FLA_Tridiag_UT_form_Q_l_opd_var1()

FLA_Error FLA_Tridiag_UT_form_Q_l_opd_var1 ( int  m_A,
int  n_AT,
double *  buff_A,
int  rs_A,
int  cs_A,
double *  buff_T,
int  rs_T,
int  cs_T 
)

◆ FLA_Tridiag_UT_form_Q_l_ops_var1()

FLA_Error FLA_Tridiag_UT_form_Q_l_ops_var1 ( int  m_A,
int  n_AT,
float *  buff_A,
int  rs_A,
int  cs_A,
float *  buff_T,
int  rs_T,
int  cs_T 
)

◆ FLA_Tridiag_UT_form_Q_l_opt_var1()

FLA_Error FLA_Tridiag_UT_form_Q_l_opt_var1 ( FLA_Obj  A,
FLA_Obj  T 
)

◆ FLA_Tridiag_UT_form_Q_l_opz_var1()

FLA_Error FLA_Tridiag_UT_form_Q_l_opz_var1 ( int  m_A,
int  n_AT,
dcomplex buff_A,
int  rs_A,
int  cs_A,
dcomplex buff_T,
int  rs_T,
int  cs_T 
)

◆ FLA_Tridiag_UT_form_Q_u_blk_var1()

FLA_Error FLA_Tridiag_UT_form_Q_u_blk_var1 ( FLA_Obj  A,
FLA_Obj  T,
FLA_Obj  W 
)

◆ FLA_Tridiag_UT_internal()

FLA_Error FLA_Tridiag_UT_internal ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  T,
fla_tridiagut_t cntl 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
18  FLA_Tridiag_UT_internal_check( uplo, A, T, cntl );
19 
20  if ( uplo == FLA_LOWER_TRIANGULAR )
21  {
22  r_val = FLA_Tridiag_UT_l( A, T, cntl );
23  }
24  else // if ( uplo == FLA_UPPER_TRIANGULAR )
25  {
26  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
27  }
28 
29  return r_val;
30 }
FLA_Error FLA_Tridiag_UT_l(FLA_Obj A, FLA_Obj T, fla_tridiagut_t *cntl)
Definition: FLA_Tridiag_UT_l.c:13
FLA_Error FLA_Tridiag_UT_internal_check(FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, fla_tridiagut_t *cntl)
Definition: FLA_Tridiag_UT_internal_check.c:13

References FLA_Check_error_level(), FLA_Tridiag_UT_internal_check(), and FLA_Tridiag_UT_l().

Referenced by FLA_Tridiag_UT().

◆ FLA_Tridiag_UT_l()

FLA_Error FLA_Tridiag_UT_l ( FLA_Obj  A,
FLA_Obj  T,
fla_tridiagut_t cntl 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT1 )
18  {
19  r_val = FLA_Tridiag_UT_l_unb_var1( A, T );
20  }
21  else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT2 )
22  {
23  r_val = FLA_Tridiag_UT_l_unb_var2( A, T );
24  }
25  else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT3 )
26  {
27  r_val = FLA_Tridiag_UT_l_unb_var3( A, T );
28  }
29  else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT1 )
30  {
31  r_val = FLA_Tridiag_UT_l_opt_var1( A, T );
32  }
33  else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT2 )
34  {
35  r_val = FLA_Tridiag_UT_l_opt_var2( A, T );
36  }
37  else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT3 )
38  {
39  r_val = FLA_Tridiag_UT_l_opt_var3( A, T );
40  }
41  else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT1 )
42  {
43  r_val = FLA_Tridiag_UT_l_blk_var1( A, T );
44  }
45  else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT2 )
46  {
47  r_val = FLA_Tridiag_UT_l_blk_var2( A, T );
48  }
49  else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT3 )
50  {
51  r_val = FLA_Tridiag_UT_l_blk_var3( A, T );
52  }
53  else if ( FLA_Cntl_variant( cntl ) == FLA_BLK_FUS_VARIANT2 )
54  {
55  r_val = FLA_Tridiag_UT_l_blf_var2( A, T );
56  }
57  else if ( FLA_Cntl_variant( cntl ) == FLA_BLK_FUS_VARIANT3 )
58  {
59  r_val = FLA_Tridiag_UT_l_blf_var3( A, T );
60  }
61  else
62  {
63  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
64  }
65 
66  return r_val;
67 }
FLA_Error FLA_Tridiag_UT_l_blf_var3(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_blf_var3.c:13
FLA_Error FLA_Tridiag_UT_l_opt_var3(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_opt_var3.c:13
FLA_Error FLA_Tridiag_UT_l_opt_var2(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_opt_var2.c:13
FLA_Error FLA_Tridiag_UT_l_blk_var1(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_blk_var1.c:13
FLA_Error FLA_Tridiag_UT_l_blk_var2(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_blk_var2.c:13
FLA_Error FLA_Tridiag_UT_l_unb_var1(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_unb_var1.c:13
FLA_Error FLA_Tridiag_UT_l_opt_var1(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_opt_var1.c:13
FLA_Error FLA_Tridiag_UT_l_blk_var3(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_blk_var3.c:13
FLA_Error FLA_Tridiag_UT_l_unb_var3(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_unb_var3.c:13
FLA_Error FLA_Tridiag_UT_l_unb_var2(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_unb_var2.c:13
FLA_Error FLA_Tridiag_UT_l_blf_var2(FLA_Obj A, FLA_Obj T)
Definition: FLA_Tridiag_UT_l_blf_var2.c:13

References FLA_Tridiag_UT_l_blf_var2(), FLA_Tridiag_UT_l_blf_var3(), FLA_Tridiag_UT_l_blk_var1(), FLA_Tridiag_UT_l_blk_var2(), FLA_Tridiag_UT_l_blk_var3(), FLA_Tridiag_UT_l_opt_var1(), FLA_Tridiag_UT_l_opt_var2(), FLA_Tridiag_UT_l_opt_var3(), FLA_Tridiag_UT_l_unb_var1(), FLA_Tridiag_UT_l_unb_var2(), and FLA_Tridiag_UT_l_unb_var3().

Referenced by FLA_Tridiag_UT_internal().

◆ FLA_Tridiag_UT_l_realify_opt()

FLA_Error FLA_Tridiag_UT_l_realify_opt ( FLA_Obj  A,
FLA_Obj  d 
)
120 {
121  FLA_Datatype datatype;
122  int m_A;
123  int rs_A, cs_A;
124  int inc_d;
125  int i;
126 
127  datatype = FLA_Obj_datatype( A );
128 
129  m_A = FLA_Obj_length( A );
130 
131  rs_A = FLA_Obj_row_stride( A );
132  cs_A = FLA_Obj_col_stride( A );
133 
134  inc_d = FLA_Obj_vector_inc( d );
135 
136 
137  switch ( datatype )
138  {
139  case FLA_FLOAT:
140  {
141  float* buff_d = FLA_FLOAT_PTR( d );
142  float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
143 
144  bl1_ssetv( m_A,
145  buff_1,
146  buff_d, inc_d );
147 
148  break;
149  }
150 
151  case FLA_DOUBLE:
152  {
153  double* buff_d = FLA_DOUBLE_PTR( d );
154  double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
155 
156  bl1_dsetv( m_A,
157  buff_1,
158  buff_d, inc_d );
159 
160  break;
161  }
162 
163  case FLA_COMPLEX:
164  {
165  scomplex* buff_A = FLA_COMPLEX_PTR( A );
166  scomplex* buff_d = FLA_COMPLEX_PTR( d );
167  scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
168 
169  bl1_csetv( 1,
170  buff_1,
171  buff_d, inc_d );
172 
173  for ( i = 1; i < m_A; ++i )
174  {
175  scomplex* a10t_r = buff_A + (i-1)*cs_A + (i )*rs_A;
176  scomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
177  scomplex* delta1 = buff_d + (i )*inc_d;
178  scomplex absv;
179  scomplex conj_delta1;
180 
181  int m_ahead = m_A - i - 1;
182 
183  // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a10t_r, delta1 );
184  // FLA_Copyt( FLA_NO_TRANSPOSE, a10t_r, absv );
185  // FLA_Absolute_value( absv );
186  // FLA_Inv_scal( absv, delta1 );
187  bl1_ccopys( BLIS1_CONJUGATE, a10t_r, delta1 );
188  bl1_cabsval2( a10t_r, &absv );
189  bl1_cinvscals( &absv, delta1 );
190 
191  // FLA_Copyt( FLA_NO_TRANSPOSE, absv, a10t_r );
192  // FLA_Scalc( FLA_CONJUGATE, delta1, a21_t );
193  *a10t_r = absv;
194  if ( m_ahead > 0 )
195  {
196  bl1_ccopyconj( delta1, &conj_delta1 );
197  bl1_cscals( &conj_delta1, a21_t );
198  }
199  }
200 
201  break;
202  }
203 
204  case FLA_DOUBLE_COMPLEX:
205  {
206  dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
207  dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
208  dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
209 
210  bl1_zsetv( 1,
211  buff_1,
212  buff_d, inc_d );
213 
214  for ( i = 1; i < m_A; ++i )
215  {
216  dcomplex* a10t_r = buff_A + (i-1)*cs_A + (i )*rs_A;
217  dcomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
218  dcomplex* delta1 = buff_d + (i )*inc_d;
219  dcomplex absv;
220  dcomplex conj_delta1;
221 
222  int m_ahead = m_A - i - 1;
223 
224  // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a10t_r, delta1 );
225  // FLA_Copyt( FLA_NO_TRANSPOSE, a10t_r, absv );
226  // FLA_Absolute_value( absv );
227  // FLA_Inv_scal( absv, delta1 );
228  bl1_zcopys( BLIS1_CONJUGATE, a10t_r, delta1 );
229  bl1_zabsval2( a10t_r, &absv );
230  bl1_zinvscals( &absv, delta1 );
231 
232  // FLA_Copyt( FLA_NO_TRANSPOSE, absv, a10t_r );
233  // FLA_Scalc( FLA_CONJUGATE, delta1, a21_t );
234  *a10t_r = absv;
235  if ( m_ahead > 0 )
236  {
237  bl1_zcopyconj( delta1, &conj_delta1 );
238  bl1_zscals( &conj_delta1, a21_t );
239  }
240  }
241 
242  break;
243  }
244  }
245 
246  return FLA_SUCCESS;
247 }
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
int i
Definition: bl1_axmyv2.c:145
bl1_zscals(beta, rho_yz)
void bl1_dsetv(int m, double *sigma, double *x, int incx)
Definition: bl1_setv.c:39
void bl1_zsetv(int m, dcomplex *sigma, dcomplex *x, int incx)
Definition: bl1_setv.c:66
void bl1_csetv(int m, scomplex *sigma, scomplex *x, int incx)
Definition: bl1_setv.c:52
void bl1_ssetv(int m, float *sigma, float *x, int incx)
Definition: bl1_setv.c:26
@ BLIS1_CONJUGATE
Definition: blis_type_defs.h:82
Definition: blis_type_defs.h:138
Definition: blis_type_defs.h:133

References bl1_csetv(), bl1_dsetv(), bl1_ssetv(), bl1_zscals(), bl1_zsetv(), BLIS1_CONJUGATE, FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_ONE, and i.

Referenced by FLA_Tridiag_UT_realify().

◆ FLA_Tridiag_UT_l_realify_unb()

FLA_Error FLA_Tridiag_UT_l_realify_unb ( FLA_Obj  A,
FLA_Obj  d 
)
38 {
39  FLA_Obj ATL, ATR, A00, a01, A02,
40  ABL, ABR, a10t, alpha11, a12t,
41  A20, a21, A22;
42 
43  FLA_Obj dT, d0,
44  dB, delta1,
45  d2;
46 
47  FLA_Obj a10t_l, a10t_r;
48 
49  FLA_Obj a21_t,
50  a21_b;
51 
52  FLA_Obj absv;
53 
54 
55  FLA_Obj_create( FLA_Obj_datatype( A ), 1, 1, 0, 0, &absv );
56 
57  FLA_Part_2x2( A, &ATL, &ATR,
58  &ABL, &ABR, 1, 1, FLA_TL );
59 
60  FLA_Part_2x1( d, &dT,
61  &dB, 1, FLA_TOP );
62 
63  // Set first element of vector d to one.
64  FLA_Set( FLA_ONE, dT );
65 
66  while ( FLA_Obj_min_dim( ABR ) > 0 )
67  {
68  FLA_Repart_2x2_to_3x3( ATL, /**/ ATR, &A00, /**/ &a01, &A02,
69  /* ************* */ /* ************************** */
70  &a10t, /**/ &alpha11, &a12t,
71  ABL, /**/ ABR, &A20, /**/ &a21, &A22,
72  1, 1, FLA_BR );
73 
74  FLA_Repart_2x1_to_3x1( dT, &d0,
75  /* ** */ /* ****** */
76  &delta1,
77  dB, &d2, 1, FLA_BOTTOM );
78 
79  /*------------------------------------------------------------*/
80 
81  FLA_Part_1x2( a10t, &a10t_l, &a10t_r, 1, FLA_RIGHT );
82 
83  FLA_Part_2x1( a21, &a21_t,
84  &a21_b, 1, FLA_TOP );
85 
86  // delta1 = conj(a10t_r) / abs(a10t_r);
87  FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a10t_r, delta1 );
88  FLA_Copyt( FLA_NO_TRANSPOSE, a10t_r, absv );
89  FLA_Absolute_value( absv );
90  FLA_Inv_scal( absv, delta1 );
91 
92  // a10t_r = delta1 * a10t_r;
93  // = abs(a10t_r);
94  // alpha11 = delta1 * alpha11 * conj(delta1);
95  // = alpha11;
96  // a21_t = a21_t * conj(delta1);
97  FLA_Copyt( FLA_NO_TRANSPOSE, absv, a10t_r );
98  FLA_Scalc( FLA_CONJUGATE, delta1, a21_t );
99 
100  /*------------------------------------------------------------*/
101 
102  FLA_Cont_with_3x3_to_2x2( &ATL, /**/ &ATR, A00, a01, /**/ A02,
103  a10t, alpha11, /**/ a12t,
104  /* ************** */ /* ************************ */
105  &ABL, /**/ &ABR, A20, a21, /**/ A22,
106  FLA_TL );
107 
108  FLA_Cont_with_3x1_to_2x1( &dT, d0,
109  delta1,
110  /* ** */ /* ****** */
111  &dB, d2, FLA_TOP );
112  }
113 
114  FLA_Obj_free( &absv );
115 
116  return FLA_SUCCESS;
117 }
FLA_Error FLA_Scalc(FLA_Conj conjalpha, FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Scalc.c:13
FLA_Error FLA_Inv_scal(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Inv_scal.c:13
FLA_Error FLA_Copyt(FLA_Trans trans, FLA_Obj A, FLA_Obj B)
Definition: FLA_Copyt.c:15
FLA_Error FLA_Cont_with_3x3_to_2x2(FLA_Obj *ATL, FLA_Obj *ATR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj *ABL, FLA_Obj *ABR, FLA_Obj A20, FLA_Obj A21, FLA_Obj A22, FLA_Quadrant quadrant)
Definition: FLA_View.c:304
FLA_Error FLA_Cont_with_3x1_to_2x1(FLA_Obj *AT, FLA_Obj A0, FLA_Obj A1, FLA_Obj *AB, FLA_Obj A2, FLA_Side side)
Definition: FLA_View.c:428
FLA_Error FLA_Repart_2x1_to_3x1(FLA_Obj AT, FLA_Obj *A0, FLA_Obj *A1, FLA_Obj AB, FLA_Obj *A2, dim_t mb, FLA_Side side)
Definition: FLA_View.c:226
FLA_Error FLA_Part_2x1(FLA_Obj A, FLA_Obj *A1, FLA_Obj *A2, dim_t mb, FLA_Side side)
Definition: FLA_View.c:76
FLA_Error FLA_Repart_2x2_to_3x3(FLA_Obj ATL, FLA_Obj ATR, FLA_Obj *A00, FLA_Obj *A01, FLA_Obj *A02, FLA_Obj *A10, FLA_Obj *A11, FLA_Obj *A12, FLA_Obj ABL, FLA_Obj ABR, FLA_Obj *A20, FLA_Obj *A21, FLA_Obj *A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)
Definition: FLA_View.c:142
FLA_Error FLA_Obj_free(FLA_Obj *obj)
Definition: FLA_Obj.c:588
FLA_Error FLA_Absolute_value(FLA_Obj alpha)
Definition: FLA_Absolute_value.c:13

References FLA_Absolute_value(), FLA_Cont_with_3x1_to_2x1(), FLA_Cont_with_3x3_to_2x2(), FLA_Copyt(), FLA_Inv_scal(), FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_free(), FLA_Obj_min_dim(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_2x1_to_3x1(), FLA_Repart_2x2_to_3x3(), FLA_Scalc(), and FLA_Set().

◆ FLA_Tridiag_UT_realify()

FLA_Error FLA_Tridiag_UT_realify ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  d 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18  FLA_Tridiag_UT_realify_check( uplo, A, d );
19 
20  if ( FLA_Obj_is_real( A ) )
21  {
22  FLA_Set( FLA_ONE, d );
23  return FLA_SUCCESS;
24  }
25 
26  if ( uplo == FLA_LOWER_TRIANGULAR )
27  //r_val = FLA_Tridiag_UT_l_realify_unb( A, d );
28  r_val = FLA_Tridiag_UT_l_realify_opt( A, d );
29  else
30  //r_val = FLA_Tridiag_UT_u_realify_unb( A, d );
31  r_val = FLA_Tridiag_UT_u_realify_opt( A, d );
32 
33  return r_val;
34 }
FLA_Error FLA_Tridiag_UT_l_realify_opt(FLA_Obj A, FLA_Obj d)
Definition: FLA_Tridiag_UT_realify.c:119
FLA_Error FLA_Tridiag_UT_u_realify_opt(FLA_Obj A, FLA_Obj d)
Definition: FLA_Tridiag_UT_realify.c:335
FLA_Error FLA_Tridiag_UT_realify_check(FLA_Uplo uplo, FLA_Obj A, FLA_Obj d)
Definition: FLA_Tridiag_UT_realify_check.c:13
FLA_Bool FLA_Obj_is_real(FLA_Obj A)
Definition: FLA_Query.c:307

References FLA_Check_error_level(), FLA_Obj_is_real(), FLA_ONE, FLA_Set(), FLA_Tridiag_UT_l_realify_opt(), FLA_Tridiag_UT_realify_check(), and FLA_Tridiag_UT_u_realify_opt().

Referenced by FLA_Hevd_lv_unb_var1(), and FLA_Hevd_lv_unb_var2().

◆ FLA_Tridiag_UT_realify_subdiagonal()

FLA_Error FLA_Tridiag_UT_realify_subdiagonal ( FLA_Obj  b,
FLA_Obj  d 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
19 
21 
22  return r_val;
23 }
FLA_Error FLA_Tridiag_UT_realify_subdiagonal_opt(FLA_Obj b, FLA_Obj d)
Definition: FLA_Tridiag_UT_realify_subdiagonal.c:25
FLA_Error FLA_Tridiag_UT_realify_subdiagonal_check(FLA_Obj b, FLA_Obj d)
Definition: FLA_Tridiag_UT_realify_subdiagonal_check.c:13

References FLA_Check_error_level(), FLA_Tridiag_UT_realify_subdiagonal_check(), and FLA_Tridiag_UT_realify_subdiagonal_opt().

◆ FLA_Tridiag_UT_realify_subdiagonal_opt()

FLA_Error FLA_Tridiag_UT_realify_subdiagonal_opt ( FLA_Obj  b,
FLA_Obj  d 
)
26 {
27  FLA_Datatype datatype;
28  int m, inc_b, inc_d;
29  int i;
30 
31  datatype = FLA_Obj_datatype( d );
32 
33  m = FLA_Obj_vector_dim( d );
34  inc_d = FLA_Obj_vector_inc( d );
35 
36  inc_b = ( m > 1 ? FLA_Obj_vector_inc( b ) : 0 );
37 
38  switch ( datatype )
39  {
40  case FLA_FLOAT:
41  {
42  float* buff_d = FLA_FLOAT_PTR( d );
43  float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
44 
45  bl1_ssetv( m,
46  buff_1,
47  buff_d, inc_d );
48 
49  break;
50  }
51  case FLA_DOUBLE:
52  {
53  double* buff_d = FLA_DOUBLE_PTR( d );
54  double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
55 
56  bl1_dsetv( m,
57  buff_1,
58  buff_d, inc_d );
59 
60  break;
61  }
62  case FLA_COMPLEX:
63  {
64  scomplex* buff_b = ( m > 1 ? FLA_COMPLEX_PTR( b ) : NULL );
65  scomplex* buff_d = FLA_COMPLEX_PTR( d );
66  scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
67 
68  bl1_csetv( 1,
69  buff_1,
70  buff_d, inc_d );
71 
72  for ( i = 1; i < m; ++i )
73  {
74  scomplex* beta1 = buff_b + (i-1)*inc_b;
75  scomplex* delta1 = buff_d + (i )*inc_d;
76  scomplex absv;
77  scomplex conj_delta1;
78 
79  if ( beta1->imag == 0.0F )
80  *delta1 = *buff_1;
81  else
82  {
83  bl1_ccopys( BLIS1_CONJUGATE, beta1, delta1 );
84  bl1_cabsval2( beta1, &absv );
85  bl1_cinvscals( &absv, delta1 );
86 
87  *beta1 = absv;
88  }
89  if ( i < ( m - 1 ) )
90  {
91  scomplex* beta2 = buff_b + (i )*inc_b;
92  bl1_ccopyconj( delta1, &conj_delta1 );
93  bl1_cscals( &conj_delta1, beta2 );
94  }
95  }
96  break;
97  }
98  case FLA_DOUBLE_COMPLEX:
99  {
100  dcomplex* buff_b = ( m > 1 ? FLA_DOUBLE_COMPLEX_PTR( b ) : NULL );
101  dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
102  dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
103 
104  bl1_zsetv( 1,
105  buff_1,
106  buff_d, inc_d );
107 
108  for ( i = 1; i < m; ++i )
109  {
110  dcomplex* beta1 = buff_b + (i-1)*inc_b;
111  dcomplex* delta1 = buff_d + (i )*inc_d;
112  dcomplex absv;
113  dcomplex conj_delta1;
114 
115  if ( beta1->imag == 0.0 )
116  *delta1 = *buff_1;
117  else
118  {
119  bl1_zcopys( BLIS1_CONJUGATE, beta1, delta1 );
120  bl1_zabsval2( beta1, &absv );
121  bl1_zinvscals( &absv, delta1 );
122 
123  *beta1 = absv;
124  }
125  if ( i < ( m - 1 ) )
126  {
127  dcomplex* beta2 = buff_b + (i )*inc_b;
128  bl1_zcopyconj( delta1, &conj_delta1 );
129  bl1_zscals( &conj_delta1, beta2 );
130  }
131  }
132  break;
133  }
134  }
135 
136  return FLA_SUCCESS;
137 }
dim_t FLA_Obj_vector_dim(FLA_Obj obj)
Definition: FLA_Query.c:137
double imag
Definition: blis_type_defs.h:139
float imag
Definition: blis_type_defs.h:134

References bl1_csetv(), bl1_dsetv(), bl1_ssetv(), bl1_zscals(), bl1_zsetv(), BLIS1_CONJUGATE, FLA_Obj_datatype(), FLA_Obj_vector_dim(), FLA_Obj_vector_inc(), FLA_ONE, i, scomplex::imag, and dcomplex::imag.

Referenced by FLA_Tridiag_UT_realify_subdiagonal().

◆ FLA_Tridiag_UT_recover_tau()

FLA_Error FLA_Tridiag_UT_recover_tau ( FLA_Obj  T,
FLA_Obj  t 
)
16 {
17  FLA_Obj TL, TR, T0, T1, T2;
18 
19  FLA_Obj tT, t0,
20  tB, t1,
21  t2;
22 
23  dim_t b_alg, b;
24 
25  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
27 
28  b_alg = FLA_Obj_length( T );
29 
30  FLA_Part_1x2( T, &TL, &TR, 0, FLA_LEFT );
31 
32  FLA_Part_2x1( t, &tT,
33  &tB, 0, FLA_TOP );
34 
35  while ( FLA_Obj_length( tT ) < FLA_Obj_length( t ) ){
36 
37  b = min( FLA_Obj_length( tB ), b_alg );
38 
39  FLA_Repart_1x2_to_1x3( TL, /**/ TR, &T0, /**/ &T1, &T2,
40  b, FLA_RIGHT );
41 
42  FLA_Repart_2x1_to_3x1( tT, &t0,
43  /* ** */ /* ** */
44  &t1,
45  tB, &t2, b, FLA_BOTTOM );
46 
47  /*------------------------------------------------------------*/
48 
50 
51  /*------------------------------------------------------------*/
52 
53  FLA_Cont_with_1x3_to_1x2( &TL, /**/ &TR, T0, T1, /**/ T2,
54  FLA_LEFT );
55 
56  FLA_Cont_with_3x1_to_2x1( &tT, t0,
57  t1,
58  /* ** */ /* ** */
59  &tB, t2, FLA_TOP );
60  }
61 
62  return FLA_SUCCESS;
63 }
FLA_Error FLA_Tridiag_UT_recover_tau_submatrix(FLA_Obj T, FLA_Obj t)
Definition: FLA_Tridiag_UT_recover_tau.c:66
FLA_Error FLA_Tridiag_UT_recover_tau_check(FLA_Obj T, FLA_Obj tau)
Definition: FLA_Tridiag_UT_recover_tau_check.c:13
FLA_Error FLA_Cont_with_1x3_to_1x2(FLA_Obj *AL, FLA_Obj *AR, FLA_Obj A0, FLA_Obj A1, FLA_Obj A2, FLA_Side side)
Definition: FLA_View.c:475
FLA_Error FLA_Repart_1x2_to_1x3(FLA_Obj AL, FLA_Obj AR, FLA_Obj *A0, FLA_Obj *A1, FLA_Obj *A2, dim_t nb, FLA_Side side)
Definition: FLA_View.c:267

References FLA_Check_error_level(), FLA_Cont_with_1x3_to_1x2(), FLA_Cont_with_3x1_to_2x1(), FLA_Obj_length(), FLA_Part_1x2(), FLA_Part_2x1(), FLA_Repart_1x2_to_1x3(), FLA_Repart_2x1_to_3x1(), FLA_Tridiag_UT_recover_tau_check(), and FLA_Tridiag_UT_recover_tau_submatrix().

◆ FLA_Tridiag_UT_scale_diagonals()

FLA_Error FLA_Tridiag_UT_scale_diagonals ( FLA_Uplo  uplo,
FLA_Obj  alpha,
FLA_Obj  A 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18  FLA_Tridiag_UT_scale_diagonals_check( uplo, alpha, A );
19 
20  if ( uplo == FLA_LOWER_TRIANGULAR )
21  r_val = FLA_Bidiag_UT_l_scale_diagonals( alpha, A );
22  else
23  r_val = FLA_Bidiag_UT_u_scale_diagonals( alpha, A );
24 
25  return r_val;
26 }
FLA_Error FLA_Bidiag_UT_u_scale_diagonals(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Bidiag_UT_scale_diagonals.c:30
FLA_Error FLA_Bidiag_UT_l_scale_diagonals(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Bidiag_UT_scale_diagonals.c:126
FLA_Error FLA_Tridiag_UT_scale_diagonals_check(FLA_Uplo uplo, FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Tridiag_UT_scale_diagonals_check.c:13

References FLA_Bidiag_UT_l_scale_diagonals(), FLA_Bidiag_UT_u_scale_diagonals(), FLA_Check_error_level(), and FLA_Tridiag_UT_scale_diagonals_check().

◆ FLA_Tridiag_UT_shift_U()

FLA_Error FLA_Tridiag_UT_shift_U ( FLA_Uplo  uplo,
FLA_Obj  A 
)
14 {
15  FLA_Datatype datatype;
16  int m_A;
17  int rs_A, cs_A;
18 
19  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
21 
22  datatype = FLA_Obj_datatype( A );
23 
24  // Play with swapping of cs rs; we do not need "u" version.
25  if ( uplo == FLA_LOWER_TRIANGULAR )
26  {
27  m_A = FLA_Obj_length( A );
28  rs_A = FLA_Obj_row_stride( A );
29  cs_A = FLA_Obj_col_stride( A );
30  }
31  else
32  {
33  m_A = FLA_Obj_width( A );
34  cs_A = FLA_Obj_row_stride( A );
35  rs_A = FLA_Obj_col_stride( A );
36  }
37 
38  switch ( datatype )
39  {
40  case FLA_FLOAT:
41  {
42  float* buff_A = ( float* ) FLA_FLOAT_PTR( A );
44  buff_A, rs_A, cs_A );
45  break;
46  }
47 
48  case FLA_DOUBLE:
49  {
50  double* buff_A = ( double* ) FLA_DOUBLE_PTR( A );
52  buff_A, rs_A, cs_A );
53  break;
54  }
55 
56  case FLA_COMPLEX:
57  {
58  scomplex* buff_A = ( scomplex* ) FLA_COMPLEX_PTR( A );
60  buff_A, rs_A, cs_A );
61  break;
62  }
63 
64  case FLA_DOUBLE_COMPLEX:
65  {
66  dcomplex* buff_A = ( dcomplex* ) FLA_DOUBLE_COMPLEX_PTR( A );
68  buff_A, rs_A, cs_A );
69  break;
70  }
71  }
72 
73  return FLA_SUCCESS;
74 }
FLA_Error FLA_Tridiag_UT_shift_U_l_ops(int m_A, float *buff_A, int rs_A, int cs_A)
Definition: FLA_Tridiag_UT_shift_U.c:78
FLA_Error FLA_Tridiag_UT_shift_U_l_opc(int m_A, scomplex *buff_A, int rs_A, int cs_A)
Definition: FLA_Tridiag_UT_shift_U.c:146
FLA_Error FLA_Tridiag_UT_shift_U_l_opd(int m_A, double *buff_A, int rs_A, int cs_A)
Definition: FLA_Tridiag_UT_shift_U.c:112
FLA_Error FLA_Tridiag_UT_shift_U_l_opz(int m_A, dcomplex *buff_A, int rs_A, int cs_A)
Definition: FLA_Tridiag_UT_shift_U.c:180
FLA_Error FLA_Tridiag_UT_shift_U_check(FLA_Uplo uplo, FLA_Obj A)
Definition: FLA_Tridiag_UT_shift_U_check.c:13
dim_t FLA_Obj_width(FLA_Obj obj)
Definition: FLA_Query.c:123

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_width(), FLA_Tridiag_UT_shift_U_check(), FLA_Tridiag_UT_shift_U_l_opc(), FLA_Tridiag_UT_shift_U_l_opd(), FLA_Tridiag_UT_shift_U_l_ops(), and FLA_Tridiag_UT_shift_U_l_opz().

Referenced by FLA_Tridiag_UT_form_Q().

◆ FLA_Tridiag_UT_shift_U_l_opc()

FLA_Error FLA_Tridiag_UT_shift_U_l_opc ( int  m_A,
scomplex buff_A,
int  rs_A,
int  cs_A 
)
148 {
149  scomplex* a00 = buff_A;
150  scomplex* a10 = buff_A + rs_A;
151  scomplex zero = bl1_c0();
152  scomplex one = bl1_c1();
153  int j;
154 
155  for ( j = m_A - 1; j > 0; --j )
156  {
157  scomplex* alpha01 = buff_A + (j )*cs_A + (0 )*rs_A;
158  scomplex* alpha11 = buff_A + (j )*cs_A + (j )*rs_A;
159  scomplex* a20 = buff_A + (j-1)*cs_A + (j+1)*rs_A;
160  scomplex* a21 = buff_A + (j )*cs_A + (j+1)*rs_A;
161 
162  int m_ahead = m_A - j - 1;
163 
164  *alpha01 = zero;
165  *alpha11 = one;
167  m_ahead,
168  a20, rs_A,
169  a21, rs_A );
170  }
171 
172  *a00 = one;
173  bl1_csetv( m_A - 1,
174  &zero,
175  a10, rs_A );
176 
177  return FLA_SUCCESS;
178 }
void bl1_ccopyv(conj1_t conj, int m, scomplex *x, int incx, scomplex *y, int incy)
Definition: bl1_copyv.c:49
scomplex bl1_c1(void)
Definition: bl1_constants.c:61
scomplex bl1_c0(void)
Definition: bl1_constants.c:125
@ BLIS1_NO_CONJUGATE
Definition: blis_type_defs.h:81

References bl1_c0(), bl1_c1(), bl1_ccopyv(), bl1_csetv(), and BLIS1_NO_CONJUGATE.

Referenced by FLA_Tridiag_UT_shift_U().

◆ FLA_Tridiag_UT_shift_U_l_opd()

FLA_Error FLA_Tridiag_UT_shift_U_l_opd ( int  m_A,
double *  buff_A,
int  rs_A,
int  cs_A 
)
114 {
115  double* a00 = buff_A;
116  double* a10 = buff_A + rs_A;
117  double zero = bl1_d0();
118  double one = bl1_d1();
119  int j;
120 
121  for ( j = m_A - 1; j > 0; --j )
122  {
123  double* alpha01 = buff_A + (j )*cs_A + (0 )*rs_A;
124  double* alpha11 = buff_A + (j )*cs_A + (j )*rs_A;
125  double* a20 = buff_A + (j-1)*cs_A + (j+1)*rs_A;
126  double* a21 = buff_A + (j )*cs_A + (j+1)*rs_A;
127 
128  int m_ahead = m_A - j - 1;
129 
130  *alpha01 = zero;
131  *alpha11 = one;
133  m_ahead,
134  a20, rs_A,
135  a21, rs_A );
136  }
137 
138  *a00 = one;
139  bl1_dsetv( m_A - 1,
140  &zero,
141  a10, rs_A );
142 
143  return FLA_SUCCESS;
144 }
void bl1_dcopyv(conj1_t conj, int m, double *x, int incx, double *y, int incy)
Definition: bl1_copyv.c:42
double bl1_d0(void)
Definition: bl1_constants.c:118
double bl1_d1(void)
Definition: bl1_constants.c:54

References bl1_d0(), bl1_d1(), bl1_dcopyv(), bl1_dsetv(), and BLIS1_NO_CONJUGATE.

Referenced by FLA_Tridiag_UT_shift_U().

◆ FLA_Tridiag_UT_shift_U_l_ops()

FLA_Error FLA_Tridiag_UT_shift_U_l_ops ( int  m_A,
float *  buff_A,
int  rs_A,
int  cs_A 
)
80 {
81  float* a00 = buff_A;
82  float* a10 = buff_A + rs_A;
83  float zero = bl1_s0();
84  float one = bl1_s1();
85  int j;
86 
87  for ( j = m_A - 1; j > 0; --j )
88  {
89  float* alpha01 = buff_A + (j )*cs_A + (0 )*rs_A;
90  float* alpha11 = buff_A + (j )*cs_A + (j )*rs_A;
91  float* a20 = buff_A + (j-1)*cs_A + (j+1)*rs_A;
92  float* a21 = buff_A + (j )*cs_A + (j+1)*rs_A;
93 
94  int m_ahead = m_A - j - 1;
95 
96  *alpha01 = zero;
97  *alpha11 = one;
99  m_ahead,
100  a20, rs_A,
101  a21, rs_A );
102  }
103 
104  *a00 = one;
105  bl1_ssetv( m_A - 1,
106  &zero,
107  a10, rs_A );
108 
109  return FLA_SUCCESS;
110 }
void bl1_scopyv(conj1_t conj, int m, float *x, int incx, float *y, int incy)
Definition: bl1_copyv.c:35
float bl1_s0(void)
Definition: bl1_constants.c:111
float bl1_s1(void)
Definition: bl1_constants.c:47

References bl1_s0(), bl1_s1(), bl1_scopyv(), bl1_ssetv(), and BLIS1_NO_CONJUGATE.

Referenced by FLA_Tridiag_UT_shift_U().

◆ FLA_Tridiag_UT_shift_U_l_opz()

FLA_Error FLA_Tridiag_UT_shift_U_l_opz ( int  m_A,
dcomplex buff_A,
int  rs_A,
int  cs_A 
)
182 {
183  dcomplex* a00 = buff_A;
184  dcomplex* a10 = buff_A + rs_A;
185  dcomplex zero = bl1_z0();
186  dcomplex one = bl1_z1();
187  int j;
188 
189  for ( j = m_A - 1; j > 0; --j )
190  {
191  dcomplex* alpha01 = buff_A + (j )*cs_A + (0 )*rs_A;
192  dcomplex* alpha11 = buff_A + (j )*cs_A + (j )*rs_A;
193  dcomplex* a20 = buff_A + (j-1)*cs_A + (j+1)*rs_A;
194  dcomplex* a21 = buff_A + (j )*cs_A + (j+1)*rs_A;
195 
196  int m_ahead = m_A - j - 1;
197 
198  *alpha01 = zero;
199  *alpha11 = one;
201  m_ahead,
202  a20, rs_A,
203  a21, rs_A );
204  }
205 
206  *a00 = one;
207  bl1_zsetv( m_A - 1,
208  &zero,
209  a10, rs_A );
210 
211  return FLA_SUCCESS;
212 }
void bl1_zcopyv(conj1_t conj, int m, dcomplex *x, int incx, dcomplex *y, int incy)
Definition: bl1_copyv.c:63
dcomplex bl1_z0(void)
Definition: bl1_constants.c:133
dcomplex bl1_z1(void)
Definition: bl1_constants.c:69

References bl1_z0(), bl1_z1(), bl1_zcopyv(), bl1_zsetv(), and BLIS1_NO_CONJUGATE.

Referenced by FLA_Tridiag_UT_shift_U().

◆ FLA_Tridiag_UT_shift_U_u_opc()

FLA_Error FLA_Tridiag_UT_shift_U_u_opc ( int  m_A,
scomplex buff_A,
int  rs_A,
int  cs_A 
)

◆ FLA_Tridiag_UT_shift_U_u_opd()

FLA_Error FLA_Tridiag_UT_shift_U_u_opd ( int  m_A,
double *  buff_A,
int  rs_A,
int  cs_A 
)

◆ FLA_Tridiag_UT_shift_U_u_ops()

FLA_Error FLA_Tridiag_UT_shift_U_u_ops ( int  m_A,
float *  buff_A,
int  rs_A,
int  cs_A 
)

◆ FLA_Tridiag_UT_shift_U_u_opz()

FLA_Error FLA_Tridiag_UT_shift_U_u_opz ( int  m_A,
dcomplex buff_A,
int  rs_A,
int  cs_A 
)

◆ FLA_Tridiag_UT_u()

FLA_Error FLA_Tridiag_UT_u ( FLA_Obj  A,
FLA_Obj  T,
fla_tridiagut_t cntl 
)
14 {
15  FLA_Error r_val = FLA_SUCCESS;
16 
17 /*
18  if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT1 )
19  {
20  r_val = FLA_Tridiag_UT_u_unb_var1( A, T );
21  }
22  else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT2 )
23  {
24  r_val = FLA_Tridiag_UT_u_unb_var2( A, T );
25  }
26  else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT3 )
27  {
28  r_val = FLA_Tridiag_UT_u_unb_var3( A, T );
29  }
30  else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT1 )
31  {
32  r_val = FLA_Tridiag_UT_u_opt_var1( A, T );
33  }
34  else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT2 )
35  {
36  r_val = FLA_Tridiag_UT_u_opt_var2( A, T );
37  }
38  else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT3 )
39  {
40  r_val = FLA_Tridiag_UT_u_opt_var3( A, T );
41  }
42  else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT1 )
43  {
44  r_val = FLA_Tridiag_UT_u_blk_var1( A, T );
45  }
46  else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT2 )
47  {
48  r_val = FLA_Tridiag_UT_u_blk_var2( A, T );
49  }
50  else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT3 )
51  {
52  r_val = FLA_Tridiag_UT_u_blk_var3( A, T );
53  }
54  else
55 */
56  {
57  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
58  }
59 
60  return r_val;
61 }

◆ FLA_Tridiag_UT_u_realify_opt()

FLA_Error FLA_Tridiag_UT_u_realify_opt ( FLA_Obj  A,
FLA_Obj  d 
)
336 {
337  FLA_Datatype datatype;
338  int m_A;
339  int rs_A, cs_A;
340  int inc_d;
341  int i;
342 
343  datatype = FLA_Obj_datatype( A );
344 
345  m_A = FLA_Obj_length( A );
346 
347  rs_A = FLA_Obj_row_stride( A );
348  cs_A = FLA_Obj_col_stride( A );
349 
350  inc_d = FLA_Obj_vector_inc( d );
351 
352 
353  switch ( datatype )
354  {
355  case FLA_FLOAT:
356  {
357  float* buff_d = FLA_FLOAT_PTR( d );
358  float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
359 
360  bl1_ssetv( m_A,
361  buff_1,
362  buff_d, inc_d );
363 
364  break;
365  }
366 
367  case FLA_DOUBLE:
368  {
369  double* buff_d = FLA_DOUBLE_PTR( d );
370  double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
371 
372  bl1_dsetv( m_A,
373  buff_1,
374  buff_d, inc_d );
375 
376  break;
377  }
378 
379  case FLA_COMPLEX:
380  {
381  scomplex* buff_A = FLA_COMPLEX_PTR( A );
382  scomplex* buff_d = FLA_COMPLEX_PTR( d );
383  scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
384 
385  bl1_csetv( 1,
386  buff_1,
387  buff_d, inc_d );
388 
389  for ( i = 1; i < m_A; ++i )
390  {
391  scomplex* a01_b = buff_A + (i )*cs_A + (i-1)*rs_A;
392  scomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
393  scomplex* delta1 = buff_d + (i )*inc_d;
394  scomplex absv;
395  scomplex conj_delta1;
396 
397  int m_ahead = m_A - i - 1;
398 
399  // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a01_b, delta1 );
400  // FLA_Copyt( FLA_NO_TRANSPOSE, a01_b, absv );
401  // FLA_Absolute_value( absv );
402  // FLA_Inv_scal( absv, delta1 );
403  bl1_ccopys( BLIS1_CONJUGATE, a01_b, delta1 );
404  bl1_cabsval2( a01_b, &absv );
405  bl1_cinvscals( &absv, delta1 );
406 
407  // FLA_Copyt( FLA_NO_TRANSPOSE, absv, a01_b );
408  // FLA_Scalc( FLA_CONJUGATE, delta1, a12t_l );
409  *a01_b = absv;
410  if ( m_ahead > 0 )
411  {
412  bl1_ccopyconj( delta1, &conj_delta1 );
413  bl1_cscals( &conj_delta1, a12t_l );
414  }
415  }
416 
417  break;
418  }
419 
420  case FLA_DOUBLE_COMPLEX:
421  {
422  dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
423  dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
424  dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
425 
426  bl1_zsetv( 1,
427  buff_1,
428  buff_d, inc_d );
429 
430  for ( i = 1; i < m_A; ++i )
431  {
432  dcomplex* a01_b = buff_A + (i )*cs_A + (i-1)*rs_A;
433  dcomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
434  dcomplex* delta1 = buff_d + (i )*inc_d;
435  dcomplex absv;
436  dcomplex conj_delta1;
437 
438  int m_ahead = m_A - i - 1;
439 
440  // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a01_b, delta1 );
441  // FLA_Copyt( FLA_NO_TRANSPOSE, a01_b, absv );
442  // FLA_Absolute_value( absv );
443  // FLA_Inv_scal( absv, delta1 );
444  bl1_zcopys( BLIS1_CONJUGATE, a01_b, delta1 );
445  bl1_zabsval2( a01_b, &absv );
446  bl1_zinvscals( &absv, delta1 );
447 
448  // FLA_Copyt( FLA_NO_TRANSPOSE, absv, a01_b );
449  // FLA_Scalc( FLA_CONJUGATE, delta1, a12t_l );
450  *a01_b = absv;
451  if ( m_ahead > 0 )
452  {
453  bl1_zcopyconj( delta1, &conj_delta1 );
454  bl1_zscals( &conj_delta1, a12t_l );
455  }
456  }
457 
458  break;
459  }
460  }
461 
462  return FLA_SUCCESS;
463 }

References bl1_csetv(), bl1_dsetv(), bl1_ssetv(), bl1_zscals(), bl1_zsetv(), BLIS1_CONJUGATE, FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_ONE, and i.

Referenced by FLA_Tridiag_UT_realify().

◆ FLA_Tridiag_UT_u_realify_unb()

FLA_Error FLA_Tridiag_UT_u_realify_unb ( FLA_Obj  A,
FLA_Obj  d 
)
253 {
254  FLA_Obj ATL, ATR, A00, a01, A02,
255  ABL, ABR, a10t, alpha11, a12t,
256  A20, a21, A22;
257 
258  FLA_Obj dT, d0,
259  dB, delta1,
260  d2;
261 
262  FLA_Obj a01_t,
263  a01_b;
264 
265  FLA_Obj a12t_l, a12t_r;
266 
267 
268  FLA_Obj absv;
269 
270 
271  FLA_Obj_create( FLA_Obj_datatype( A ), 1, 1, 0, 0, &absv );
272 
273  FLA_Part_2x2( A, &ATL, &ATR,
274  &ABL, &ABR, 1, 1, FLA_TL );
275 
276  FLA_Part_2x1( d, &dT,
277  &dB, 1, FLA_TOP );
278 
279  // Set first element of vector d to one.
280  FLA_Set( FLA_ONE, dT );
281 
282  while ( FLA_Obj_min_dim( ABR ) > 0 )
283  {
284  FLA_Repart_2x2_to_3x3( ATL, /**/ ATR, &A00, /**/ &a01, &A02,
285  /* ************* */ /* ************************** */
286  &a10t, /**/ &alpha11, &a12t,
287  ABL, /**/ ABR, &A20, /**/ &a21, &A22,
288  1, 1, FLA_BR );
289 
290  FLA_Repart_2x1_to_3x1( dT, &d0,
291  /* ** */ /* ****** */
292  &delta1,
293  dB, &d2, 1, FLA_BOTTOM );
294 
295  /*------------------------------------------------------------*/
296 
297  FLA_Part_2x1( a01, &a01_t,
298  &a01_b, 1, FLA_BOTTOM );
299 
300  FLA_Part_1x2( a12t, &a12t_l, &a12t_r, 1, FLA_LEFT );
301 
302  // delta1 = conj(a01_b) / abs(a01_b);
303  FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a01_b, delta1 );
304  FLA_Copyt( FLA_NO_TRANSPOSE, a01_b, absv );
305  FLA_Absolute_value( absv );
306  FLA_Inv_scal( absv, delta1 );
307 
308  // a01_b = delta1 * a01_b;
309  // = abs(a01_b);
310  // alpha11 = delta1 * alpha11 * conj(delta1);
311  // = alpha11;
312  // a12t_l = a12t_l * conj(delta1);
313  FLA_Copyt( FLA_NO_TRANSPOSE, absv, a01_b );
314  FLA_Scalc( FLA_CONJUGATE, delta1, a12t_l );
315 
316  /*------------------------------------------------------------*/
317 
318  FLA_Cont_with_3x3_to_2x2( &ATL, /**/ &ATR, A00, a01, /**/ A02,
319  a10t, alpha11, /**/ a12t,
320  /* ************** */ /* ************************ */
321  &ABL, /**/ &ABR, A20, a21, /**/ A22,
322  FLA_TL );
323 
324  FLA_Cont_with_3x1_to_2x1( &dT, d0,
325  delta1,
326  /* ** */ /* ****** */
327  &dB, d2, FLA_TOP );
328  }
329 
330  FLA_Obj_free( &absv );
331 
332  return FLA_SUCCESS;
333 }

References FLA_Absolute_value(), FLA_Cont_with_3x1_to_2x1(), FLA_Cont_with_3x3_to_2x2(), FLA_Copyt(), FLA_Inv_scal(), FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_free(), FLA_Obj_min_dim(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_2x1_to_3x1(), FLA_Repart_2x2_to_3x3(), FLA_Scalc(), and FLA_Set().